(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)
(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 Rank (Term) Int)
(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)) 
(< (Rank t1) (Rank 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)))


;;; Start module Prims

; Externals for module Prims


; <Start encoding Prims.attribute>

(declare-fun Prims.attribute () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.attribute; Namespace Prims
(assert (! (HasType Prims.attribute
Tm_type)
:named function_token_typing_Prims.attribute))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.attribute; Namespace Prims
(assert (! (= 101
(Term_constr_id Prims.attribute))
:named constructor_distinct_Prims.attribute))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.attribute; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(38,5-38,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(38,5-38,14)
(forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.attribute)
(= Prims.attribute
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
Prims.attribute))
:qid Prims_pretyping_84eeee553eff3e9aec239a06e72d1d36))

:named Prims_pretyping_84eeee553eff3e9aec239a06e72d1d36))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.attribute; Namespace Prims
(assert (! (HasType Prims.attribute
Tm_type)
:named typing_Prims.attribute))

; </end encoding Prims.attribute>


; <Start encoding Prims.cps>

(declare-fun Prims.cps () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.cps; Namespace Prims
(assert (! (HasType Prims.cps
Prims.attribute)
:named function_token_typing_Prims.cps))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.cps; Namespace Prims
(assert (! (HasType Prims.cps
Prims.attribute)
:named typing_Prims.cps))

; </end encoding Prims.cps>


; <Start encoding Prims.hasEq>

(declare-fun Prims.hasEq (Term) Term)
;;;;;;;;;;;;;;;;_: Type -> Prims.GTot Type
(declare-fun Tm_arrow_ef9cb512a25ee351fa5536d617490497 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ef9cb512a25ee351fa5536d617490497
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert (! (HasType Tm_arrow_ef9cb512a25ee351fa5536d617490497
Tm_type)
:named kinding_Tm_arrow_ef9cb512a25ee351fa5536d617490497))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,26-48,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,26-48,31)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ef9cb512a25ee351fa5536d617490497)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ef9cb512a25ee351fa5536d617490497))
:qid Prims_pre_typing_Tm_arrow_ef9cb512a25ee351fa5536d617490497))

:named Prims_pre_typing_Tm_arrow_ef9cb512a25ee351fa5536d617490497))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ef9cb512a25ee351fa5536d617490497
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,26-48,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,26-48,31)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ef9cb512a25ee351fa5536d617490497)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,26-48,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,26-48,31)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
Tm_type))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_ef9cb512a25ee351fa5536d617490497.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ef9cb512a25ee351fa5536d617490497))
:qid Prims_interpretation_Tm_arrow_ef9cb512a25ee351fa5536d617490497))

:named Prims_interpretation_Tm_arrow_ef9cb512a25ee351fa5536d617490497))
(declare-fun Prims.hasEq@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.hasEq@tok
@x0)
(Prims.hasEq @x0))
 

:pattern ((ApplyTT Prims.hasEq@tok
@x0))
:qid token_correspondence_Prims.hasEq))

:named token_correspondence_Prims.hasEq))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.hasEq@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.hasEq@tok
@x1)
(Prims.hasEq @x1))
 

:pattern ((Prims.hasEq @x1))
:qid function_token_typing_Prims.hasEq.1))
)
 

:pattern ((ApplyTT @x0
Prims.hasEq@tok))
:qid function_token_typing_Prims.hasEq))

:named function_token_typing_Prims.hasEq))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.hasEq; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(48,5-48,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))

; </end encoding Prims.hasEq>


; <Start encoding Prims.eqtype>

(declare-fun Prims.eqtype () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert (! (HasType Prims.eqtype
Tm_type)
:named function_token_typing_Prims.eqtype))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert (! (HasType Prims.eqtype
Tm_type)
:named typing_Prims.eqtype))
(declare-fun Tm_refine_414d0a9f578ab0048252f8c8f552b99f () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert (! (HasType Tm_refine_414d0a9f578ab0048252f8c8f552b99f
Tm_type)
:named refinement_kinding_Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(52,14-52,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(52,14-52,31)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_414d0a9f578ab0048252f8c8f552b99f)
(and (HasTypeFuel @u0
@x1
Tm_type)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(52,23-52,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(52,23-52,30)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(52,23-52,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(52,23-52,30)
(Prims.hasEq @x1)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
:qid refinement_interpretation_Tm_refine_414d0a9f578ab0048252f8c8f552b99f))

:named refinement_interpretation_Tm_refine_414d0a9f578ab0048252f8c8f552b99f))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Equation for Prims.eqtype
;;; Fact-ids: Name Prims.eqtype; Namespace Prims
(assert (! (= Prims.eqtype
Tm_refine_414d0a9f578ab0048252f8c8f552b99f)
:named equation_Prims.eqtype))

; </end encoding Prims.eqtype>


; <Start encoding Prims.bool>

(declare-fun Prims.bool () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert (! (HasType Prims.bool
Prims.eqtype)
:named function_token_typing_Prims.bool))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert (! (= 107
(Term_constr_id Prims.bool))
:named constructor_distinct_Prims.bool))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(59,5-59,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(59,5-59,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))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.bool; Namespace Prims
(assert (! (HasType Prims.bool
Prims.eqtype)
:named typing_Prims.bool))
;;;;;;;;;;;;;;;;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))

; </end encoding Prims.bool>


; <Start encoding Prims.empty>

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.empty () Term)

; <Start encoding Prims.empty>


; <start constructor Prims.empty>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.empty; Namespace Prims
(assert (! (= 111
(Term_constr_id Prims.empty))
:named constructor_distinct_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>

;;; Fact-ids: Name Prims.empty; Namespace Prims
(assert (! (HasType Prims.empty
Tm_type)
:named kinding_Prims.empty@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.empty; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(65,5-65,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(65,5-65,10)
(forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.empty)
(= Prims.empty
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
Prims.empty))
:qid Prims_pretyping_012c410d173b30f0cec8f55be7b4958c))

:named Prims_pretyping_012c410d173b30f0cec8f55be7b4958c))

; </end encoding Prims.empty>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.empty; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(65,5-65,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(65,5-65,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.empty)
false)
 

:pattern ((HasTypeFuel @u0
@x1
Prims.empty))
:qid fuel_guarded_inversion_Prims.empty))

:named fuel_guarded_inversion_Prims.empty))

; </end encoding Prims.empty>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.trivial () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.T () Term)
;;;;;;;;;;;;;;;;data constructor proxy: T
(declare-fun Prims.T@tok () Term)

; <Start encoding Prims.trivial>


; <start constructor Prims.trivial>

;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.trivial ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
116)
(= __@x0
Prims.trivial)))

; </end constructor Prims.trivial>

;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert (! (HasType Prims.trivial
Tm_type)
:named kinding_Prims.trivial@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,5-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,5-70,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))

; </end encoding Prims.trivial>


; <Start encoding Prims.T>


; <start constructor Prims.T>

;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.T ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
122)
(= __@x0
Prims.T)))

; </end constructor Prims.T>

;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,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))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert (! true
:named data_elim_Prims.T))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert (! true
:named subterm_ordering_Prims.T))

; </end encoding Prims.T>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.trivial; Namespace Prims; Name Prims.T; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,5-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,5-70,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))

; </end encoding >


; <Start encoding Prims.uu___is_T>

(declare-fun Prims.uu___is_T (Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.trivial -> Prims.bool
(declare-fun Tm_arrow_053f01f066524059a49c5dc621e6494a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_053f01f066524059a49c5dc621e6494a
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! (HasType Tm_arrow_053f01f066524059a49c5dc621e6494a
Tm_type)
:named kinding_Tm_arrow_053f01f066524059a49c5dc621e6494a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_053f01f066524059a49c5dc621e6494a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_053f01f066524059a49c5dc621e6494a))
:qid Prims_pre_typing_Tm_arrow_053f01f066524059a49c5dc621e6494a))
:named Prims_pre_typing_Tm_arrow_053f01f066524059a49c5dc621e6494a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_053f01f066524059a49c5dc621e6494a
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_053f01f066524059a49c5dc621e6494a)
(and (forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.trivial)
(HasType (ApplyTT @x0
@x1)
Prims.bool))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_053f01f066524059a49c5dc621e6494a.1))
(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_053f01f066524059a49c5dc621e6494a))
:qid Prims_interpretation_Tm_arrow_053f01f066524059a49c5dc621e6494a))
:named Prims_interpretation_Tm_arrow_053f01f066524059a49c5dc621e6494a))
(declare-fun Prims.uu___is_T@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.uu___is_T@tok
@x0)
(Prims.uu___is_T @x0))
 

:pattern ((ApplyTT Prims.uu___is_T@tok
@x0))
:qid token_correspondence_Prims.uu___is_T))

:named token_correspondence_Prims.uu___is_T))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_T@tok
Tm_arrow_053f01f066524059a49c5dc621e6494a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.uu___is_T@tok
@x1)
(Prims.uu___is_T @x1))
 

:pattern ((Prims.uu___is_T @x1))
:qid function_token_typing_Prims.uu___is_T.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_T@tok))
:qid function_token_typing_Prims.uu___is_T))

:named function_token_typing_Prims.uu___is_T))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.trivial)
(HasType (Prims.uu___is_T @x0)
Prims.bool))
 

:pattern ((Prims.uu___is_T @x0))
:qid typing_Prims.uu___is_T))

:named typing_Prims.uu___is_T))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_T; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(70,17-70,18)
(forall ((@x0 Term))
 (! (= (Prims.uu___is_T @x0)
(BoxBool (is-Prims.T @x0)))
 

:pattern ((Prims.uu___is_T @x0))
:qid disc_equation_Prims.T))

:named disc_equation_Prims.T))

; </end encoding Prims.uu___is_T>


; <Start encoding Prims.unit>

(declare-fun Prims.unit () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert (! (HasType Prims.unit
Prims.eqtype)
:named function_token_typing_Prims.unit))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert (! (= 125
(Term_constr_id Prims.unit))
:named constructor_distinct_Prims.unit))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(75,5-75,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(75,5-75,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))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.unit; Namespace Prims
(assert (! (HasType Prims.unit
Prims.eqtype)
:named typing_Prims.unit))
;;;;;;;;;;;;;;;;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))

; </end encoding Prims.unit>


; <Start encoding Prims.squash>

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

(declare-fun Prims.squash@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.squash@tok
@x0)
(Prims.squash @x0))
 

:pattern ((ApplyTT Prims.squash@tok
@x0))
:qid token_correspondence_Prims.squash))

:named token_correspondence_Prims.squash))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.squash@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.squash@tok
@x1)
(Prims.squash @x1))
 

:pattern ((Prims.squash @x1))
:qid function_token_typing_Prims.squash.1))
)
 

:pattern ((ApplyTT @x0
Prims.squash@tok))
:qid function_token_typing_Prims.squash))

:named function_token_typing_Prims.squash))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,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))
(declare-fun Tm_refine_2de20c066034c13bf76e9c0b94f4806c (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,32-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,32-96,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.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,32-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,32-96,42)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x2))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,13-96,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,40-96,41)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,13-96,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,40-96,41)
@x2
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x2)))
:qid refinement_interpretation_Tm_refine_2de20c066034c13bf76e9c0b94f4806c))

:named refinement_interpretation_Tm_refine_2de20c066034c13bf76e9c0b94f4806c))
;;;;;;;;;;;;;;;;haseq for Tm_refine_2de20c066034c13bf76e9c0b94f4806c
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,32-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,32-96,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))
;;;;;;;;;;;;;;;;Equation for Prims.squash
;;; Fact-ids: Name Prims.squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(96,5-96,11)
(forall ((@x0 Term))
 (! (= (Prims.squash @x0)
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0))
 

:pattern ((Prims.squash @x0))
:qid equation_Prims.squash))

:named equation_Prims.squash))

; </end encoding Prims.squash>


; <Start encoding Prims.auto_squash>

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

(declare-fun Prims.auto_squash@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.auto_squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.auto_squash@tok
@x0)
(Prims.auto_squash @x0))
 

:pattern ((ApplyTT Prims.auto_squash@tok
@x0))
:qid token_correspondence_Prims.auto_squash))

:named token_correspondence_Prims.auto_squash))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.auto_squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.auto_squash@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.auto_squash@tok
@x1)
(Prims.auto_squash @x1))
 

:pattern ((Prims.auto_squash @x1))
:qid function_token_typing_Prims.auto_squash.1))
)
 

:pattern ((ApplyTT @x0
Prims.auto_squash@tok))
:qid function_token_typing_Prims.auto_squash))

:named function_token_typing_Prims.auto_squash))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.auto_squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.auto_squash @x0)
Tm_type))
 

:pattern ((Prims.auto_squash @x0))
:qid typing_Prims.auto_squash))

:named typing_Prims.auto_squash))
;;;;;;;;;;;;;;;;Equation for Prims.auto_squash
;;; Fact-ids: Name Prims.auto_squash; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(109,4-109,15)
(forall ((@x0 Term))
 (! (= (Prims.auto_squash @x0)
(Prims.squash @x0))
 

:pattern ((Prims.auto_squash @x0))
:qid equation_Prims.auto_squash))

:named equation_Prims.auto_squash))

; </end encoding Prims.auto_squash>


; <Start encoding Prims.logical>

(declare-fun Prims.logical () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.logical; Namespace Prims
(assert (! (HasType Prims.logical
Tm_type)
:named function_token_typing_Prims.logical))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.logical; Namespace Prims
(assert (! (HasType Prims.logical
Tm_type)
:named typing_Prims.logical))
;;;;;;;;;;;;;;;;Equation for Prims.logical
;;; Fact-ids: Name Prims.logical; Namespace Prims
(assert (! (= Prims.logical
Tm_type)
:named equation_Prims.logical))

; </end encoding Prims.logical>


; <Start encoding Prims.smt_theory_symbol>

(declare-fun Prims.smt_theory_symbol () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.smt_theory_symbol; Namespace Prims
(assert (! (HasType Prims.smt_theory_symbol
Prims.attribute)
:named function_token_typing_Prims.smt_theory_symbol))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.smt_theory_symbol; Namespace Prims
(assert (! (HasType Prims.smt_theory_symbol
Prims.attribute)
:named typing_Prims.smt_theory_symbol))

; </end encoding Prims.smt_theory_symbol>


; <Start encoding Prims.l_True>

(declare-fun Prims.l_True () Term)
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_True; Namespace Prims
(assert (! (HasType Prims.l_True
Prims.logical)
:named typing_Prims.l_True))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;True interpretation
;;; Fact-ids: Name Prims.l_True; Namespace Prims
(assert (! (Valid Prims.l_True)
:named true_interp))

; </end encoding Prims.l_True>


; <Start encoding Prims.l_False>

(declare-fun Prims.l_False () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_False; Namespace Prims
(assert (! (HasType Prims.l_False
Prims.logical)
:named function_token_typing_Prims.l_False))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_False; Namespace Prims
(assert (! (HasType Prims.l_False
Prims.logical)
:named typing_Prims.l_False))
;;;;;;;;;;;;;;;;Equation for Prims.l_False
;;; Fact-ids: Name Prims.l_False; Namespace Prims
(assert (! (= Prims.l_False
(Prims.squash Prims.empty))
:named equation_Prims.l_False))
;;;;;;;;;;;;;;;;False interpretation
;;; Fact-ids: Name Prims.l_False; Namespace Prims
(assert (! (iff false
(Valid Prims.l_False))
:named false_interp))

; </end encoding Prims.l_False>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.equals (Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.equals@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.equals@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.equals@x2 (Term) Term)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.equals@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Refl (Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Refl_a (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Refl_x (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: Refl
(declare-fun Prims.Refl@tok () Term)
;;;;;;;;;;;;;;;;Prims.equals x x
(declare-fun Tm_arrow_8e00c6263684633abbc1d1a87608e391 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8e00c6263684633abbc1d1a87608e391
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! (HasType Tm_arrow_8e00c6263684633abbc1d1a87608e391
Tm_type)
:named kinding_Tm_arrow_8e00c6263684633abbc1d1a87608e391))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8e00c6263684633abbc1d1a87608e391)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8e00c6263684633abbc1d1a87608e391))
:qid Prims_pre_typing_Tm_arrow_8e00c6263684633abbc1d1a87608e391))

:named Prims_pre_typing_Tm_arrow_8e00c6263684633abbc1d1a87608e391))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8e00c6263684633abbc1d1a87608e391
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8e00c6263684633abbc1d1a87608e391)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(Prims.equals @x1
@x2
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_8e00c6263684633abbc1d1a87608e391.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,53-144,63)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_8e00c6263684633abbc1d1a87608e391.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8e00c6263684633abbc1d1a87608e391))
:qid Prims_interpretation_Tm_arrow_8e00c6263684633abbc1d1a87608e391))

:named Prims_interpretation_Tm_arrow_8e00c6263684633abbc1d1a87608e391))

; <Start encoding Prims.equals>


; <start constructor Prims.equals>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,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))
;;;;;;;;;;;;;;;;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))
 
;;no pats
:qid is-Prims.equals))))

; </end constructor 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))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.equals@tok
@x0))
 

:pattern ((ApplyTT Prims.equals@tok
@x0))
:qid kinding_Prims.equals@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,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))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.equals @x2
@x3
@x4))
(= (Prims.equals @x2
@x3
@x4)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(Prims.equals @x2
@x3
@x4)))
:qid Prims_pretyping_b2d64ca214b8828a9eba2c140aea0816))

:named Prims_pretyping_b2d64ca214b8828a9eba2c140aea0816))

; </end encoding Prims.equals>


; <Start encoding Prims.Refl>


; <start constructor Prims.Refl>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,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))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.Refl_a (Prims.Refl @x0
@x1))
@x0)
 

:pattern ((Prims.Refl @x0
@x1))
:qid projection_inverse_Prims.Refl_a))

:named projection_inverse_Prims.Refl_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.Refl_x (Prims.Refl @x0
@x1))
@x1)
 

:pattern ((Prims.Refl @x0
@x1))
:qid projection_inverse_Prims.Refl_x))

:named projection_inverse_Prims.Refl_x))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Refl ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
141)
(= __@x0
(Prims.Refl (Prims.Refl_a __@x0)
(Prims.Refl_x __@x0)))))

; </end constructor Prims.Refl>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! (= 144
(Term_constr_id Prims.Refl@tok))
:named fresh_token_Prims.Refl@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Refl@tok
Tm_arrow_8e00c6263684633abbc1d1a87608e391))
 

:pattern ((ApplyTT Prims.Refl@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Refl@tok))
:qid typing_tok_Prims.Refl@tok))

:named typing_tok_Prims.Refl@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.Refl@tok
@x0)
@x1)
(Prims.Refl @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.Refl@tok
@x0)
@x1))
:qid equality_tok_Prims.Refl@tok))

:named equality_tok_Prims.Refl@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,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 (= @x2
@x5)
(HasTypeFuel @u0
@x4
@x1)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x2
@x3)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
@x1)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Refl @x1
@x2)
(Prims.equals @x3
@x4
@x5)))
:qid data_elim_Prims.Refl))

:named data_elim_Prims.Refl))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! true
:named subterm_ordering_Prims.Refl))

; </end encoding Prims.Refl>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.equals; Namespace Prims; Name Prims.Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,5-144,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Prims.equals @x2
@x3
@x4))
(and (is-Prims.Refl @x1)
(= @x2
(Prims.Refl_a @x1))
(= @x3
(Prims.Refl_x @x1))
(= @x4
(Prims.Refl_x @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(Prims.equals @x2
@x3
@x4)))
:qid fuel_guarded_inversion_Prims.equals))

:named fuel_guarded_inversion_Prims.equals))

; </end encoding >


; <Start encoding Prims.uu___is_Refl>

(declare-fun Prims.uu___is_Refl (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.equals x _ -> Prims.bool
(declare-fun Tm_arrow_2a4540f76c8969717ea911077d7b4d15 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2a4540f76c8969717ea911077d7b4d15
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! (HasType Tm_arrow_2a4540f76c8969717ea911077d7b4d15
Tm_type)
:named kinding_Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2a4540f76c8969717ea911077d7b4d15)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
:qid Prims_pre_typing_Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
:named Prims_pre_typing_Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2a4540f76c8969717ea911077d7b4d15)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
@x1)
(HasType @x4
(Prims.equals @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid Prims_interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15.4))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
:qid Prims_interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
:named Prims_interpretation_Tm_arrow_2a4540f76c8969717ea911077d7b4d15))
(declare-fun Prims.uu___is_Refl@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Refl@tok
@x0)
@x1)
@x2)
@x3)
(Prims.uu___is_Refl @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Refl@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_Prims.uu___is_Refl))

:named token_correspondence_Prims.uu___is_Refl))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Refl@tok
Tm_arrow_2a4540f76c8969717ea911077d7b4d15))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Refl@tok
@x1)
@x2)
@x3)
@x4)
(Prims.uu___is_Refl @x1
@x2
@x3
@x4))
 

:pattern ((Prims.uu___is_Refl @x1
@x2
@x3
@x4))
:qid function_token_typing_Prims.uu___is_Refl.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Refl@tok))
:qid function_token_typing_Prims.uu___is_Refl))

:named function_token_typing_Prims.uu___is_Refl))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0)
(HasType @x2
@x0)
(HasType @x3
(Prims.equals @x0
@x1
@x2)))
(HasType (Prims.uu___is_Refl @x0
@x1
@x2
@x3)
Prims.bool))
 

:pattern ((Prims.uu___is_Refl @x0
@x1
@x2
@x3))
:qid typing_Prims.uu___is_Refl))

:named typing_Prims.uu___is_Refl))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Refl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(144,46-144,50)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.uu___is_Refl @x0
@x1
@x2
@x3)
(BoxBool (is-Prims.Refl @x3)))
 

:pattern ((Prims.uu___is_Refl @x0
@x1
@x2
@x3))
:qid disc_equation_Prims.Refl))

:named disc_equation_Prims.Refl))

; </end encoding Prims.uu___is_Refl>


; <Start encoding Prims.eq2>

(declare-fun Prims.eq2 (Term Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> y: a -> Prims.logical
(declare-fun Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! (HasType Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7
Tm_type)
:named kinding_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))
:qid Prims_pre_typing_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))

:named Prims_pre_typing_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,36-154,43)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))
:qid Prims_interpretation_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))

:named Prims_interpretation_Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))
(declare-fun Prims.eq2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.eq2@tok
@x0)
@x1)
@x2)
(Prims.eq2 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.eq2@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.eq2))

:named token_correspondence_Prims.eq2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.eq2@tok
Tm_arrow_1ec40cec1da281b45a559c74dd57f3b7))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.eq2@tok
@x1)
@x2)
@x3)
(Prims.eq2 @x1
@x2
@x3))
 

:pattern ((Prims.eq2 @x1
@x2
@x3))
:qid function_token_typing_Prims.eq2.1))
)
 

:pattern ((ApplyTT @x0
Prims.eq2@tok))
:qid function_token_typing_Prims.eq2))

:named function_token_typing_Prims.eq2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,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))
;;;;;;;;;;;;;;;;Equation for Prims.eq2
;;; Fact-ids: Name Prims.eq2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,5-154,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))

; </end encoding Prims.eq2>


; <Start encoding Prims.b2t>

(declare-fun Prims.b2t (Term) Term)
;;;;;;;;;;;;;;;;b2t def
;;; Fact-ids: Name Prims.b2t; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(159,5-159,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(159,5-159,8)
(forall ((@x0 Term))
 (! (= (Valid (Prims.b2t @x0))
(BoxBool_proj_0 @x0))
 

:pattern ((Prims.b2t @x0))
:qid b2t_def))

:named b2t_def))
;;;;;;;;;;;;;;;;b2t typing
;;; Fact-ids: Name Prims.b2t; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(159,5-159,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(159,5-159,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))

; </end encoding Prims.b2t>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.pair (Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.pair@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.pair@x1 (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: Pair
(declare-fun Prims.Pair@tok () Term)
;;;;;;;;;;;;;;;;_1: p -> _2: q -> Prims.pair p q
(declare-fun Tm_arrow_e2b0096073073582c70f249d40f91c5d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e2b0096073073582c70f249d40f91c5d
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! (HasType Tm_arrow_e2b0096073073582c70f249d40f91c5d
Tm_type)
:named kinding_Tm_arrow_e2b0096073073582c70f249d40f91c5d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e2b0096073073582c70f249d40f91c5d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e2b0096073073582c70f249d40f91c5d))
:qid Prims_pre_typing_Tm_arrow_e2b0096073073582c70f249d40f91c5d))

:named Prims_pre_typing_Tm_arrow_e2b0096073073582c70f249d40f91c5d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e2b0096073073582c70f249d40f91c5d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1)
(HasType @x4
@x2))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Prims.pair @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid Prims_interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,57-162,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e2b0096073073582c70f249d40f91c5d))
:qid Prims_interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d))

:named Prims_interpretation_Tm_arrow_e2b0096073073582c70f249d40f91c5d))

; <Start encoding Prims.pair>


; <start constructor Prims.pair>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= 150
(Term_constr_id (Prims.pair @x0
@x1)))
 

:pattern ((Prims.pair @x0
@x1))
:qid constructor_distinct_Prims.pair))

:named constructor_distinct_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))
 
;;no pats
:qid is-Prims.pair))))

; </end constructor Prims.pair>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! (= 151
(Term_constr_id Prims.pair@tok))
:named fresh_token_Prims.pair@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.pair@tok
@x0)
@x1)
(Prims.pair @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.pair@tok
@x0)
@x1))

:pattern ((Prims.pair @x0
@x1))
:qid token_correspondence_Prims.pair@tok))

:named token_correspondence_Prims.pair@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! (is-Tm_arrow (PreType Prims.pair@tok))
:named pre_kinding_Prims.pair@tok))
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! (and (IsTotFun Prims.pair@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.pair@tok
@x0))
 

:pattern ((ApplyTT Prims.pair@tok
@x0))
:qid kinding_Prims.pair@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (Prims.pair @x0
@x1)
Tm_type))
 

:pattern ((Prims.pair @x0
@x1))
:qid kinding_Prims.pair@tok.1))
)
:named kinding_Prims.pair@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.pair @x2
@x3))
(= (Prims.pair @x2
@x3)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(Prims.pair @x2
@x3)))
:qid Prims_pretyping_b7882067459c08225ce8e64864e7b31f))

:named Prims_pretyping_b7882067459c08225ce8e64864e7b31f))

; </end encoding Prims.pair>


; <Start encoding Prims.Pair>


; <start constructor Prims.Pair>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= 157
(Term_constr_id (Prims.Pair @x0
@x1
@x2
@x3)))
 

:pattern ((Prims.Pair @x0
@x1
@x2
@x3))
:qid constructor_distinct_Prims.Pair))

:named constructor_distinct_Prims.Pair))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Pair_p (Prims.Pair @x0
@x1
@x2
@x3))
@x0)
 

:pattern ((Prims.Pair @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Pair_p))

:named projection_inverse_Prims.Pair_p))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Pair_q (Prims.Pair @x0
@x1
@x2
@x3))
@x1)
 

:pattern ((Prims.Pair @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Pair_q))

:named projection_inverse_Prims.Pair_q))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Pair__1 (Prims.Pair @x0
@x1
@x2
@x3))
@x2)
 

:pattern ((Prims.Pair @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Pair__1))

:named projection_inverse_Prims.Pair__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Pair__2 (Prims.Pair @x0
@x1
@x2
@x3))
@x3)
 

:pattern ((Prims.Pair @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Pair__2))

:named projection_inverse_Prims.Pair__2))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! (= 160
(Term_constr_id Prims.Pair@tok))
:named fresh_token_Prims.Pair@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Pair@tok
Tm_arrow_e2b0096073073582c70f249d40f91c5d))
 

:pattern ((ApplyTT Prims.Pair@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Pair@tok))
:qid typing_tok_Prims.Pair@tok))

:named typing_tok_Prims.Pair@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Pair@tok
@x0)
@x1)
@x2)
@x3)
(Prims.Pair @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Pair@tok
@x0)
@x1)
@x2)
@x3))
:qid equality_tok_Prims.Pair@tok))

:named equality_tok_Prims.Pair@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1)
(HasTypeFuel @u0
@x4
@x2))
(HasTypeFuel @u0
(Prims.Pair @x1
@x2
@x3
@x4)
(Prims.pair @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(Prims.Pair @x1
@x2
@x3
@x4)
(Prims.pair @x1
@x2)))
:qid data_typing_intro_Prims.Pair@tok))

:named data_typing_intro_Prims.Pair@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Pair @x1
@x2
@x3
@x4)
(Prims.pair @x5
@x6))
(and (HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x4
@x6)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x3
@x5)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1)
(HasTypeFuel @u0
@x4
@x2)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Pair @x1
@x2
@x3
@x4)
(Prims.pair @x5
@x6)))
:qid data_elim_Prims.Pair))

:named data_elim_Prims.Pair))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Pair @x1
@x2
@x3
@x4)
(Prims.pair @x5
@x6))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(Prims.Pair @x1
@x2
@x3
@x4)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x4
(Prims.Pair @x1
@x2
@x3
@x4)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Pair @x1
@x2
@x3
@x4)
(Prims.pair @x5
@x6)))
:qid subterm_ordering_Prims.Pair))

:named subterm_ordering_Prims.Pair))

; </end encoding Prims.Pair>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.pair; Namespace Prims; Name Prims.Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,5-162,9)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Prims.pair @x2
@x3))
(and (is-Prims.Pair @x1)
(= @x2
(Prims.Pair_p @x1))
(= @x3
(Prims.Pair_q @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(Prims.pair @x2
@x3)))
:qid fuel_guarded_inversion_Prims.pair))

:named fuel_guarded_inversion_Prims.pair))

; </end encoding >


; <Start encoding Prims.uu___is_Pair>

(declare-fun Prims.uu___is_Pair (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.pair p q -> Prims.bool
(declare-fun Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! (HasType Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2
Tm_type)
:named kinding_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
:qid Prims_pre_typing_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
:named Prims_pre_typing_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pair @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2.3))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
:qid Prims_interpretation_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
:named Prims_interpretation_Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))
(declare-fun Prims.uu___is_Pair@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Pair@tok
@x0)
@x1)
@x2)
(Prims.uu___is_Pair @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Pair@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.uu___is_Pair))

:named token_correspondence_Prims.uu___is_Pair))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Pair@tok
Tm_arrow_0a519c999e1325381ee4c9b1d93a06b2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Pair@tok
@x1)
@x2)
@x3)
(Prims.uu___is_Pair @x1
@x2
@x3))
 

:pattern ((Prims.uu___is_Pair @x1
@x2
@x3))
:qid function_token_typing_Prims.uu___is_Pair.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Pair@tok))
:qid function_token_typing_Prims.uu___is_Pair))

:named function_token_typing_Prims.uu___is_Pair))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.pair @x0
@x1)))
(HasType (Prims.uu___is_Pair @x0
@x1
@x2)
Prims.bool))
 

:pattern ((Prims.uu___is_Pair @x0
@x1
@x2))
:qid typing_Prims.uu___is_Pair))

:named typing_Prims.uu___is_Pair))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Pair; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,34-162,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.uu___is_Pair @x0
@x1
@x2)
(BoxBool (is-Prims.Pair @x2)))
 

:pattern ((Prims.uu___is_Pair @x0
@x1
@x2))
:qid disc_equation_Prims.Pair))

:named disc_equation_Prims.Pair))

; </end encoding Prims.uu___is_Pair>


; <Start encoding Prims.__proj__Pair__item___1>

(declare-fun Prims.__proj__Pair__item___1 (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.pair p q -> p
(declare-fun Tm_arrow_214b45775d1504fb2699ff0d156b6857 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_214b45775d1504fb2699ff0d156b6857
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! (HasType Tm_arrow_214b45775d1504fb2699ff0d156b6857
Tm_type)
:named kinding_Tm_arrow_214b45775d1504fb2699ff0d156b6857))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_214b45775d1504fb2699ff0d156b6857)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_214b45775d1504fb2699ff0d156b6857))
:qid Prims_pre_typing_Tm_arrow_214b45775d1504fb2699ff0d156b6857))

:named Prims_pre_typing_Tm_arrow_214b45775d1504fb2699ff0d156b6857))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_214b45775d1504fb2699ff0d156b6857
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_214b45775d1504fb2699ff0d156b6857)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pair @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_214b45775d1504fb2699ff0d156b6857.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_214b45775d1504fb2699ff0d156b6857.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,11-162,12)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_214b45775d1504fb2699ff0d156b6857.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_214b45775d1504fb2699ff0d156b6857))
:qid Prims_interpretation_Tm_arrow_214b45775d1504fb2699ff0d156b6857))

:named Prims_interpretation_Tm_arrow_214b45775d1504fb2699ff0d156b6857))
(declare-fun Prims.__proj__Pair__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Pair__item___1@tok
@x0)
@x1)
@x2)
(Prims.__proj__Pair__item___1 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.__proj__Pair__item___1@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.__proj__Pair__item___1))

:named token_correspondence_Prims.__proj__Pair__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Pair__item___1@tok
Tm_arrow_214b45775d1504fb2699ff0d156b6857))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Pair__item___1@tok
@x1)
@x2)
@x3)
(Prims.__proj__Pair__item___1 @x1
@x2
@x3))
 

:pattern ((Prims.__proj__Pair__item___1 @x1
@x2
@x3))
:qid function_token_typing_Prims.__proj__Pair__item___1.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Pair__item___1@tok))
:qid function_token_typing_Prims.__proj__Pair__item___1))

:named function_token_typing_Prims.__proj__Pair__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.pair @x0
@x1)))
(HasType (Prims.__proj__Pair__item___1 @x0
@x1
@x2)
@x0))
 

:pattern ((Prims.__proj__Pair__item___1 @x0
@x1
@x2))
:qid typing_Prims.__proj__Pair__item___1))

:named typing_Prims.__proj__Pair__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Pair__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,41-162,43)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.__proj__Pair__item___1 @x0
@x1
@x2)
(Prims.Pair__1 @x2))
 

:pattern ((Prims.__proj__Pair__item___1 @x0
@x1
@x2))
:qid proj_equation_Prims.Pair__1))

:named proj_equation_Prims.Pair__1))

; </end encoding Prims.__proj__Pair__item___1>


; <Start encoding Prims.__proj__Pair__item___2>

(declare-fun Prims.__proj__Pair__item___2 (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.pair p q -> q
(declare-fun Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! (HasType Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3
Tm_type)
:named kinding_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))
:qid Prims_pre_typing_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))

:named Prims_pre_typing_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pair @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,21-162,22)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))
:qid Prims_interpretation_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))

:named Prims_interpretation_Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))
(declare-fun Prims.__proj__Pair__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Pair__item___2@tok
@x0)
@x1)
@x2)
(Prims.__proj__Pair__item___2 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.__proj__Pair__item___2@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.__proj__Pair__item___2))

:named token_correspondence_Prims.__proj__Pair__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Pair__item___2@tok
Tm_arrow_1b97dbe8f5eb289f51cc2556690371e3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Pair__item___2@tok
@x1)
@x2)
@x3)
(Prims.__proj__Pair__item___2 @x1
@x2
@x3))
 

:pattern ((Prims.__proj__Pair__item___2 @x1
@x2
@x3))
:qid function_token_typing_Prims.__proj__Pair__item___2.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Pair__item___2@tok))
:qid function_token_typing_Prims.__proj__Pair__item___2))

:named function_token_typing_Prims.__proj__Pair__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.pair @x0
@x1)))
(HasType (Prims.__proj__Pair__item___2 @x0
@x1
@x2)
@x1))
 

:pattern ((Prims.__proj__Pair__item___2 @x0
@x1
@x2))
:qid typing_Prims.__proj__Pair__item___2))

:named typing_Prims.__proj__Pair__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Pair__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(162,49-162,51)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.__proj__Pair__item___2 @x0
@x1
@x2)
(Prims.Pair__2 @x2))
 

:pattern ((Prims.__proj__Pair__item___2 @x0
@x1
@x2))
:qid proj_equation_Prims.Pair__2))

:named proj_equation_Prims.Pair__2))

; </end encoding Prims.__proj__Pair__item___2>


; <Start encoding Prims.l_and>

(declare-fun Prims.l_and (Term Term) Term)
;;;;;;;;;;;;;;;;p: Prims.logical -> q: Prims.logical -> Prims.logical
(declare-fun Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! (HasType Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6
Tm_type)
:named kinding_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))
:qid Prims_pre_typing_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))

:named Prims_pre_typing_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Prims.logical)
(HasType @x2
Prims.logical))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.logical)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))
:qid Prims_interpretation_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))

:named Prims_interpretation_Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))
(declare-fun Prims.l_and@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_and@tok
@x0)
@x1)
(Prims.l_and @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.l_and@tok
@x0)
@x1))
:qid token_correspondence_Prims.l_and))

:named token_correspondence_Prims.l_and))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_and@tok
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_and@tok
@x1)
@x2)
(Prims.l_and @x1
@x2))
 

:pattern ((Prims.l_and @x1
@x2))
:qid function_token_typing_Prims.l_and.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_and@tok))
:qid function_token_typing_Prims.l_and))

:named function_token_typing_Prims.l_and))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.logical)
(HasType @x1
Prims.logical))
(HasType (Prims.l_and @x0
@x1)
Prims.logical))
 

:pattern ((Prims.l_and @x0
@x1))
:qid typing_Prims.l_and))

:named typing_Prims.l_and))
;;;;;;;;;;;;;;;;Equation for Prims.l_and
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,5-167,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.l_and @x0
@x1)
(Prims.squash (Prims.pair @x0
@x1)))
 

:pattern ((Prims.l_and @x0
@x1))
:qid equation_Prims.l_and))

:named equation_Prims.l_and))
;;;;;;;;;;;;;;;;/\ interpretation
;;; Fact-ids: Name Prims.l_and; Namespace Prims
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (iff (and (Valid @x0)
(Valid @x1))
(Valid (Prims.l_and @x0
@x1)))
 

:pattern ((Prims.l_and @x0
@x1))
:qid l_and-interp))
:named l_and-interp))

; </end encoding Prims.l_and>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.sum (Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.sum@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.sum@x1 (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: 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: Right
(declare-fun Prims.Right@tok () Term)
;;;;;;;;;;;;;;;;v: p -> Prims.sum p q
(declare-fun Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (HasType Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd
Tm_type)
:named kinding_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))
:qid Prims_pre_typing_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))

:named Prims_pre_typing_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Prims.sum @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,18-171,25)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))
:qid Prims_interpretation_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))

:named Prims_interpretation_Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))
;;;;;;;;;;;;;;;;v: q -> Prims.sum p q
(declare-fun Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (HasType Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0
Tm_type)
:named kinding_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))
:qid Prims_pre_typing_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))

:named Prims_pre_typing_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x2))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Prims.sum @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,19-172,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))
:qid Prims_interpretation_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))

:named Prims_interpretation_Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))

; <Start encoding Prims.sum>


; <start constructor Prims.sum>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= 169
(Term_constr_id (Prims.sum @x0
@x1)))
 

:pattern ((Prims.sum @x0
@x1))
:qid constructor_distinct_Prims.sum))

:named constructor_distinct_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))
 
;;no pats
:qid is-Prims.sum))))

; </end constructor Prims.sum>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (= 170
(Term_constr_id Prims.sum@tok))
:named fresh_token_Prims.sum@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.sum@tok
@x0)
@x1)
(Prims.sum @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.sum@tok
@x0)
@x1))

:pattern ((Prims.sum @x0
@x1))
:qid token_correspondence_Prims.sum@tok))

:named token_correspondence_Prims.sum@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (is-Tm_arrow (PreType Prims.sum@tok))
:named pre_kinding_Prims.sum@tok))
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (and (IsTotFun Prims.sum@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.sum@tok
@x0))
 

:pattern ((ApplyTT Prims.sum@tok
@x0))
:qid kinding_Prims.sum@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (Prims.sum @x0
@x1)
Tm_type))
 

:pattern ((Prims.sum @x0
@x1))
:qid kinding_Prims.sum@tok.1))
)
:named kinding_Prims.sum@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.sum @x2
@x3))
(= (Prims.sum @x2
@x3)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(Prims.sum @x2
@x3)))
:qid Prims_pretyping_a08d262d1ccaf451d982ca8ce0bf4ae9))

:named Prims_pretyping_a08d262d1ccaf451d982ca8ce0bf4ae9))

; </end encoding Prims.sum>


; <Start encoding Prims.Left>


; <start constructor Prims.Left>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 176
(Term_constr_id (Prims.Left @x0
@x1
@x2)))
 

:pattern ((Prims.Left @x0
@x1
@x2))
:qid constructor_distinct_Prims.Left))

:named constructor_distinct_Prims.Left))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.Left_p (Prims.Left @x0
@x1
@x2))
@x0)
 

:pattern ((Prims.Left @x0
@x1
@x2))
:qid projection_inverse_Prims.Left_p))

:named projection_inverse_Prims.Left_p))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.Left_q (Prims.Left @x0
@x1
@x2))
@x1)
 

:pattern ((Prims.Left @x0
@x1
@x2))
:qid projection_inverse_Prims.Left_q))

:named projection_inverse_Prims.Left_q))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.Left_v (Prims.Left @x0
@x1
@x2))
@x2)
 

:pattern ((Prims.Left @x0
@x1
@x2))
:qid projection_inverse_Prims.Left_v))

:named projection_inverse_Prims.Left_v))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (= 179
(Term_constr_id Prims.Left@tok))
:named fresh_token_Prims.Left@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Left@tok
Tm_arrow_4ef073c03ed003774fe6ccb4064aeebd))
 

:pattern ((ApplyTT Prims.Left@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Left@tok))
:qid typing_tok_Prims.Left@tok))

:named typing_tok_Prims.Left@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.Left@tok
@x0)
@x1)
@x2)
(Prims.Left @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.Left@tok
@x0)
@x1)
@x2))
:qid equality_tok_Prims.Left@tok))

:named equality_tok_Prims.Left@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1))
(HasTypeFuel @u0
(Prims.Left @x1
@x2
@x3)
(Prims.sum @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(Prims.Left @x1
@x2
@x3)
(Prims.sum @x1
@x2)))
:qid data_typing_intro_Prims.Left@tok))

:named data_typing_intro_Prims.Left@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Left @x1
@x2
@x3)
(Prims.sum @x4
@x5))
(and (HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x3
@x4)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Left @x1
@x2
@x3)
(Prims.sum @x4
@x5)))
:qid data_elim_Prims.Left))

:named data_elim_Prims.Left))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Left @x1
@x2
@x3)
(Prims.sum @x4
@x5))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(Prims.Left @x1
@x2
@x3))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Left @x1
@x2
@x3)
(Prims.sum @x4
@x5)))
:qid subterm_ordering_Prims.Left))

:named subterm_ordering_Prims.Left))

; </end encoding Prims.Left>


; <Start encoding Prims.Right>


; <start constructor Prims.Right>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 181
(Term_constr_id (Prims.Right @x0
@x1
@x2)))
 

:pattern ((Prims.Right @x0
@x1
@x2))
:qid constructor_distinct_Prims.Right))

:named constructor_distinct_Prims.Right))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.Right_p (Prims.Right @x0
@x1
@x2))
@x0)
 

:pattern ((Prims.Right @x0
@x1
@x2))
:qid projection_inverse_Prims.Right_p))

:named projection_inverse_Prims.Right_p))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.Right_q (Prims.Right @x0
@x1
@x2))
@x1)
 

:pattern ((Prims.Right @x0
@x1
@x2))
:qid projection_inverse_Prims.Right_q))

:named projection_inverse_Prims.Right_q))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.Right_v (Prims.Right @x0
@x1
@x2))
@x2)
 

:pattern ((Prims.Right @x0
@x1
@x2))
:qid projection_inverse_Prims.Right_v))

:named projection_inverse_Prims.Right_v))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! (= 184
(Term_constr_id Prims.Right@tok))
:named fresh_token_Prims.Right@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Right@tok
Tm_arrow_c537ccd7fef2183d55f1a6960ee793b0))
 

:pattern ((ApplyTT Prims.Right@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Right@tok))
:qid typing_tok_Prims.Right@tok))

:named typing_tok_Prims.Right@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.Right@tok
@x0)
@x1)
@x2)
(Prims.Right @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.Right@tok
@x0)
@x1)
@x2))
:qid equality_tok_Prims.Right@tok))

:named equality_tok_Prims.Right@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x2))
(HasTypeFuel @u0
(Prims.Right @x1
@x2
@x3)
(Prims.sum @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(Prims.Right @x1
@x2
@x3)
(Prims.sum @x1
@x2)))
:qid data_typing_intro_Prims.Right@tok))

:named data_typing_intro_Prims.Right@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Right @x1
@x2
@x3)
(Prims.sum @x4
@x5))
(and (HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x3
@x5)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x2)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Right @x1
@x2
@x3)
(Prims.sum @x4
@x5)))
:qid data_elim_Prims.Right))

:named data_elim_Prims.Right))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Right @x1
@x2
@x3)
(Prims.sum @x4
@x5))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(Prims.Right @x1
@x2
@x3))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Right @x1
@x2
@x3)
(Prims.sum @x4
@x5)))
:qid subterm_ordering_Prims.Right))

:named subterm_ordering_Prims.Right))

; </end encoding Prims.Right>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.sum; Namespace Prims; Name Prims.Left; Namespace Prims; Name Prims.Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,5-170,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.sum @x2
@x3))
(or (and (is-Prims.Left @x1)
(= @x2
(Prims.Left_p @x1))
(= @x3
(Prims.Left_q @x1)))
(and (is-Prims.Right @x1)
(= @x2
(Prims.Right_p @x1))
(= @x3
(Prims.Right_q @x1)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.sum @x2
@x3)))
:qid fuel_guarded_inversion_Prims.sum))

:named fuel_guarded_inversion_Prims.sum))

; </end encoding >


; <Start encoding Prims.uu___is_Left>

(declare-fun Prims.uu___is_Left (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.sum p q -> Prims.bool
(declare-fun Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! (HasType Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c
Tm_type)
:named kinding_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
:qid Prims_pre_typing_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
:named Prims_pre_typing_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.sum @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c.3))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
:qid Prims_interpretation_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
:named Prims_interpretation_Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))
(declare-fun Prims.uu___is_Left@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Left@tok
@x0)
@x1)
@x2)
(Prims.uu___is_Left @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Left@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.uu___is_Left))

:named token_correspondence_Prims.uu___is_Left))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Left@tok
Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Left@tok
@x1)
@x2)
@x3)
(Prims.uu___is_Left @x1
@x2
@x3))
 

:pattern ((Prims.uu___is_Left @x1
@x2
@x3))
:qid function_token_typing_Prims.uu___is_Left.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Left@tok))
:qid function_token_typing_Prims.uu___is_Left))

:named function_token_typing_Prims.uu___is_Left))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.sum @x0
@x1)))
(HasType (Prims.uu___is_Left @x0
@x1
@x2)
Prims.bool))
 

:pattern ((Prims.uu___is_Left @x0
@x1
@x2))
:qid typing_Prims.uu___is_Left))

:named typing_Prims.uu___is_Left))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Left; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.uu___is_Left @x0
@x1
@x2)
(BoxBool (is-Prims.Left @x2)))
 

:pattern ((Prims.uu___is_Left @x0
@x1
@x2))
:qid disc_equation_Prims.Left))

:named disc_equation_Prims.Left))

; </end encoding Prims.uu___is_Left>


; <Start encoding Prims.__proj__Left__item__v>

(declare-fun Tm_refine_6140be01a70b18051829f178aaf0270b (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_6140be01a70b18051829f178aaf0270b @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_6140be01a70b18051829f178aaf0270b @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_6140be01a70b18051829f178aaf0270b))

:named refinement_kinding_Tm_refine_6140be01a70b18051829f178aaf0270b))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_6140be01a70b18051829f178aaf0270b @x2
@x3))
(and (HasTypeFuel @u0
@x1
(Prims.sum @x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(BoxBool_proj_0 (Prims.uu___is_Left @x2
@x3
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_6140be01a70b18051829f178aaf0270b @x2
@x3)))
:qid refinement_interpretation_Tm_refine_6140be01a70b18051829f178aaf0270b))

:named refinement_interpretation_Tm_refine_6140be01a70b18051829f178aaf0270b))
;;;;;;;;;;;;;;;;haseq for Tm_refine_6140be01a70b18051829f178aaf0270b
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,4-171,8)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_6140be01a70b18051829f178aaf0270b @x0
@x1)))
(Valid (Prims.hasEq (Prims.sum @x0
@x1))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_6140be01a70b18051829f178aaf0270b @x0
@x1))))
:qid haseqTm_refine_6140be01a70b18051829f178aaf0270b))

:named haseqTm_refine_6140be01a70b18051829f178aaf0270b))
(declare-fun Prims.__proj__Left__item__v (Term Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: Prims.sum p q {Left? _} -> p
(declare-fun Tm_arrow_aaf070885513892396497eef726adce1 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_aaf070885513892396497eef726adce1
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! (HasType Tm_arrow_aaf070885513892396497eef726adce1
Tm_type)
:named kinding_Tm_arrow_aaf070885513892396497eef726adce1))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_aaf070885513892396497eef726adce1)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_aaf070885513892396497eef726adce1))
:qid Prims_pre_typing_Tm_arrow_aaf070885513892396497eef726adce1))

:named Prims_pre_typing_Tm_arrow_aaf070885513892396497eef726adce1))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_aaf070885513892396497eef726adce1
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_aaf070885513892396497eef726adce1)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_6140be01a70b18051829f178aaf0270b @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_aaf070885513892396497eef726adce1.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_aaf070885513892396497eef726adce1.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,10-170,11)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_aaf070885513892396497eef726adce1.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_aaf070885513892396497eef726adce1))
:qid Prims_interpretation_Tm_arrow_aaf070885513892396497eef726adce1))

:named Prims_interpretation_Tm_arrow_aaf070885513892396497eef726adce1))
(declare-fun Prims.__proj__Left__item__v@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Left__item__v@tok
@x0)
@x1)
@x2)
(Prims.__proj__Left__item__v @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.__proj__Left__item__v@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.__proj__Left__item__v))

:named token_correspondence_Prims.__proj__Left__item__v))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Left__item__v@tok
Tm_arrow_aaf070885513892396497eef726adce1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Left__item__v@tok
@x1)
@x2)
@x3)
(Prims.__proj__Left__item__v @x1
@x2
@x3))
 

:pattern ((Prims.__proj__Left__item__v @x1
@x2
@x3))
:qid function_token_typing_Prims.__proj__Left__item__v.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Left__item__v@tok))
:qid function_token_typing_Prims.__proj__Left__item__v))

:named function_token_typing_Prims.__proj__Left__item__v))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_6140be01a70b18051829f178aaf0270b @x0
@x1)))
(HasType (Prims.__proj__Left__item__v @x0
@x1
@x2)
@x0))
 

:pattern ((Prims.__proj__Left__item__v @x0
@x1
@x2))
:qid typing_Prims.__proj__Left__item__v))

:named typing_Prims.__proj__Left__item__v))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Left__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(171,11-171,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.__proj__Left__item__v @x0
@x1
@x2)
(Prims.Left_v @x2))
 

:pattern ((Prims.__proj__Left__item__v @x0
@x1
@x2))
:qid proj_equation_Prims.Left_v))

:named proj_equation_Prims.Left_v))

; </end encoding Prims.__proj__Left__item__v>


; <Start encoding Prims.uu___is_Right>

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

(declare-fun Prims.uu___is_Right@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Right@tok
@x0)
@x1)
@x2)
(Prims.uu___is_Right @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Right@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.uu___is_Right))

:named token_correspondence_Prims.uu___is_Right))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Right@tok
Tm_arrow_3c254c463840bdea2ca63f23cf7c2f0c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Right@tok
@x1)
@x2)
@x3)
(Prims.uu___is_Right @x1
@x2
@x3))
 

:pattern ((Prims.uu___is_Right @x1
@x2
@x3))
:qid function_token_typing_Prims.uu___is_Right.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Right@tok))
:qid function_token_typing_Prims.uu___is_Right))

:named function_token_typing_Prims.uu___is_Right))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.sum @x0
@x1)))
(HasType (Prims.uu___is_Right @x0
@x1
@x2)
Prims.bool))
 

:pattern ((Prims.uu___is_Right @x0
@x1
@x2))
:qid typing_Prims.uu___is_Right))

:named typing_Prims.uu___is_Right))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Right; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.uu___is_Right @x0
@x1
@x2)
(BoxBool (is-Prims.Right @x2)))
 

:pattern ((Prims.uu___is_Right @x0
@x1
@x2))
:qid disc_equation_Prims.Right))

:named disc_equation_Prims.Right))

; </end encoding Prims.uu___is_Right>


; <Start encoding Prims.__proj__Right__item__v>

(declare-fun Tm_refine_43ea5cf89e866ce271f97bd6ce102588 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_43ea5cf89e866ce271f97bd6ce102588))

:named refinement_kinding_Tm_refine_43ea5cf89e866ce271f97bd6ce102588))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x2
@x3))
(and (HasTypeFuel @u0
@x1
(Prims.sum @x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(BoxBool_proj_0 (Prims.uu___is_Right @x2
@x3
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_43ea5cf89e866ce271f97bd6ce102588))

:named refinement_interpretation_Tm_refine_43ea5cf89e866ce271f97bd6ce102588))
;;;;;;;;;;;;;;;;haseq for Tm_refine_43ea5cf89e866ce271f97bd6ce102588
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,4-172,9)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x0
@x1)))
(Valid (Prims.hasEq (Prims.sum @x0
@x1))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x0
@x1))))
:qid haseqTm_refine_43ea5cf89e866ce271f97bd6ce102588))

:named haseqTm_refine_43ea5cf89e866ce271f97bd6ce102588))
(declare-fun Prims.__proj__Right__item__v (Term Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: Prims.sum p q {Right? _} -> q
(declare-fun Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! (HasType Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f
Tm_type)
:named kinding_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))
:qid Prims_pre_typing_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))

:named Prims_pre_typing_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(170,20-170,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))
:qid Prims_interpretation_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))

:named Prims_interpretation_Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))
(declare-fun Prims.__proj__Right__item__v@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Right__item__v@tok
@x0)
@x1)
@x2)
(Prims.__proj__Right__item__v @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.__proj__Right__item__v@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.__proj__Right__item__v))

:named token_correspondence_Prims.__proj__Right__item__v))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Right__item__v@tok
Tm_arrow_4ae0e7dd85e55aec7e8190dea6e3997f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Right__item__v@tok
@x1)
@x2)
@x3)
(Prims.__proj__Right__item__v @x1
@x2
@x3))
 

:pattern ((Prims.__proj__Right__item__v @x1
@x2
@x3))
:qid function_token_typing_Prims.__proj__Right__item__v.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Right__item__v@tok))
:qid function_token_typing_Prims.__proj__Right__item__v))

:named function_token_typing_Prims.__proj__Right__item__v))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_43ea5cf89e866ce271f97bd6ce102588 @x0
@x1)))
(HasType (Prims.__proj__Right__item__v @x0
@x1
@x2)
@x1))
 

:pattern ((Prims.__proj__Right__item__v @x0
@x1
@x2))
:qid typing_Prims.__proj__Right__item__v))

:named typing_Prims.__proj__Right__item__v))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Right__item__v; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(172,12-172,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.__proj__Right__item__v @x0
@x1
@x2)
(Prims.Right_v @x2))
 

:pattern ((Prims.__proj__Right__item__v @x0
@x1
@x2))
:qid proj_equation_Prims.Right_v))

:named proj_equation_Prims.Right_v))

; </end encoding Prims.__proj__Right__item__v>


; <Start encoding Prims.l_or>

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

(declare-fun Prims.l_or@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_or; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_or@tok
@x0)
@x1)
(Prims.l_or @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.l_or@tok
@x0)
@x1))
:qid token_correspondence_Prims.l_or))

:named token_correspondence_Prims.l_or))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_or; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_or@tok
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_or@tok
@x1)
@x2)
(Prims.l_or @x1
@x2))
 

:pattern ((Prims.l_or @x1
@x2))
:qid function_token_typing_Prims.l_or.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_or@tok))
:qid function_token_typing_Prims.l_or))

:named function_token_typing_Prims.l_or))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_or; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.logical)
(HasType @x1
Prims.logical))
(HasType (Prims.l_or @x0
@x1)
Prims.logical))
 

:pattern ((Prims.l_or @x0
@x1))
:qid typing_Prims.l_or))

:named typing_Prims.l_or))
;;;;;;;;;;;;;;;;Equation for Prims.l_or
;;; Fact-ids: Name Prims.l_or; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(177,5-177,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.l_or @x0
@x1)
(Prims.squash (Prims.sum @x0
@x1)))
 

:pattern ((Prims.l_or @x0
@x1))
:qid equation_Prims.l_or))

:named equation_Prims.l_or))
;;;;;;;;;;;;;;;;\/ interpretation
;;; Fact-ids: Name Prims.l_or; Namespace Prims
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (iff (or (Valid @x0)
(Valid @x1))
(Valid (Prims.l_or @x0
@x1)))
 

:pattern ((Prims.l_or @x0
@x1))
:qid l_or-interp))
:named l_or-interp))

; </end encoding Prims.l_or>


; <Start encoding Prims.l_imp>

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

(declare-fun Prims.l_imp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_imp@tok
@x0)
@x1)
(Prims.l_imp @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.l_imp@tok
@x0)
@x1))
:qid token_correspondence_Prims.l_imp))

:named token_correspondence_Prims.l_imp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_imp@tok
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_imp@tok
@x1)
@x2)
(Prims.l_imp @x1
@x2))
 

:pattern ((Prims.l_imp @x1
@x2))
:qid function_token_typing_Prims.l_imp.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_imp@tok))
:qid function_token_typing_Prims.l_imp))

:named function_token_typing_Prims.l_imp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.logical)
(HasType @x1
Prims.logical))
(HasType (Prims.l_imp @x0
@x1)
Prims.logical))
 

:pattern ((Prims.l_imp @x0
@x1))
:qid typing_Prims.l_imp))

:named typing_Prims.l_imp))
;;;;;;;;;;;;;;;;_: p -> Prims.GTot q
(declare-fun Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,25-183,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,67-183,68)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x0
@x1)
Tm_type))
:qid kinding_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a))

:named kinding_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,25-183,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,67-183,68)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x2
@x3)))
:qid Prims_pre_typing_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a))

:named Prims_pre_typing_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a))
;;;;;;;;;;;;;;;;interpretation_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,25-183,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,67-183,68)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x1
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,25-183,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,67-183,68)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(HasType (ApplyTT @x0
@x3)
@x1))
 

:pattern ((ApplyTT @x0
@x3))
:qid Prims_interpretation_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a.1))
)
 

:pattern ((HasTypeZ @x0
(Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x1
@x2)))
:qid Prims_interpretation_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a))

:named Prims_interpretation_Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a))
;;;;;;;;;;;;;;;;Equation for Prims.l_imp
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(183,5-183,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.l_imp @x0
@x1)
(Prims.squash (Tm_ghost_arrow_0283b8a2a36bbec52abac4e3d837674a @x1
@x0)))
 

:pattern ((Prims.l_imp @x0
@x1))
:qid equation_Prims.l_imp))

:named equation_Prims.l_imp))
;;;;;;;;;;;;;;;;==> interpretation
;;; Fact-ids: Name Prims.l_imp; Namespace Prims
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (iff (implies (Valid @x0)
(Valid @x1))
(Valid (Prims.l_imp @x0
@x1)))
 

:pattern ((Prims.l_imp @x0
@x1))
:qid l_imp-interp))
:named l_imp-interp))

; </end encoding Prims.l_imp>


; <Start encoding Prims.l_iff>

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

(declare-fun Prims.l_iff@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_iff; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_iff@tok
@x0)
@x1)
(Prims.l_iff @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.l_iff@tok
@x0)
@x1))
:qid token_correspondence_Prims.l_iff))

:named token_correspondence_Prims.l_iff))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_iff; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_iff@tok
Tm_arrow_289ee2cc5874944bf725b9e3db8c0fd6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_iff@tok
@x1)
@x2)
(Prims.l_iff @x1
@x2))
 

:pattern ((Prims.l_iff @x1
@x2))
:qid function_token_typing_Prims.l_iff.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_iff@tok))
:qid function_token_typing_Prims.l_iff))

:named function_token_typing_Prims.l_iff))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_iff; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.logical)
(HasType @x1
Prims.logical))
(HasType (Prims.l_iff @x0
@x1)
Prims.logical))
 

:pattern ((Prims.l_iff @x0
@x1))
:qid typing_Prims.l_iff))

:named typing_Prims.l_iff))
;;;;;;;;;;;;;;;;Equation for Prims.l_iff
;;; Fact-ids: Name Prims.l_iff; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(189,5-189,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.l_iff @x0
@x1)
(Prims.l_and (Prims.l_imp @x0
@x1)
(Prims.l_imp @x1
@x0)))
 

:pattern ((Prims.l_iff @x0
@x1))
:qid equation_Prims.l_iff))

:named equation_Prims.l_iff))
;;;;;;;;;;;;;;;;<==> interpretation
;;; Fact-ids: Name Prims.l_iff; Namespace Prims
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (iff (iff (Valid @x0)
(Valid @x1))
(Valid (Prims.l_iff @x0
@x1)))
 

:pattern ((Prims.l_iff @x0
@x1))
:qid l_iff-interp))
:named l_iff-interp))

; </end encoding Prims.l_iff>


; <Start encoding Prims.l_not>

(declare-fun Prims.l_not (Term) Term)
;;;;;;;;;;;;;;;;p: Prims.logical -> Prims.logical
(declare-fun Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! (HasType Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711
Tm_type)
:named kinding_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,26-193,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,26-193,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))
:qid Prims_pre_typing_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))

:named Prims_pre_typing_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,26-193,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,26-193,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,26-193,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,26-193,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.logical)
(HasType (ApplyTT @x0
@x1)
Prims.logical))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))
:qid Prims_interpretation_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))

:named Prims_interpretation_Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))
(declare-fun Prims.l_not@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.l_not@tok
@x0)
(Prims.l_not @x0))
 

:pattern ((ApplyTT Prims.l_not@tok
@x0))
:qid token_correspondence_Prims.l_not))

:named token_correspondence_Prims.l_not))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_not@tok
Tm_arrow_8178e3b6934aa50ea45bb0ccea2d9711))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.l_not@tok
@x1)
(Prims.l_not @x1))
 

:pattern ((Prims.l_not @x1))
:qid function_token_typing_Prims.l_not.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_not@tok))
:qid function_token_typing_Prims.l_not))

:named function_token_typing_Prims.l_not))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.logical)
(HasType (Prims.l_not @x0)
Prims.logical))
 

:pattern ((Prims.l_not @x0))
:qid typing_Prims.l_not))

:named typing_Prims.l_not))
;;;;;;;;;;;;;;;;Equation for Prims.l_not
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(193,5-193,10)
(forall ((@x0 Term))
 (! (= (Prims.l_not @x0)
(Prims.l_imp @x0
Prims.l_False))
 

:pattern ((Prims.l_not @x0))
:qid equation_Prims.l_not))

:named equation_Prims.l_not))
;;;;;;;;;;;;;;;;not interpretation
;;; Fact-ids: Name Prims.l_not; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (not (Valid @x0))
(Valid (Prims.l_not @x0)))
 

:pattern ((Prims.l_not @x0))
:qid l_not-interp))
:named l_not-interp))

; </end encoding Prims.l_not>


; <Skipped Prims.l_ITE/>


; <Skipped Prims.precedes/>


; <Start encoding Prims.string>

(declare-fun Prims.string () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.string; Namespace Prims
(assert (! (HasType Prims.string
Prims.eqtype)
:named function_token_typing_Prims.string))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.string; Namespace Prims
(assert (! (= 207
(Term_constr_id Prims.string))
:named constructor_distinct_Prims.string))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.string; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(218,5-218,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(218,5-218,11)
(forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.string)
(= Prims.string
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
Prims.string))
:qid Prims_pretyping_ce036b6b736ef4e0bc3a9ff132a12aed))

:named Prims_pretyping_ce036b6b736ef4e0bc3a9ff132a12aed))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.string; Namespace Prims
(assert (! (HasType Prims.string
Prims.eqtype)
:named typing_Prims.string))
;;;;;;;;;;;;;;;;string typing
;;; Fact-ids: Name Prims.string; Namespace Prims
(assert (! (forall ((@u0 FString))
 (! (HasType (BoxString @u0)
Prims.string)
 

:pattern ((BoxString @u0))
:qid string_typing))
:named string_typing))
;;;;;;;;;;;;;;;;string inversion
;;; Fact-ids: Name Prims.string; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(is-BoxString @x1))
 

:pattern ((HasTypeFuel @u0
@x1
Prims.string))
:qid string_inversion))
:named string_inversion))

; </end encoding Prims.string>


; <Start encoding Prims.warn_on_use>

(declare-fun Prims.warn_on_use (Term) Term)
;;;;;;;;;;;;;;;;msg: Prims.string -> Prims.unit
(declare-fun Tm_arrow_2863eb88d7490a9c3cf347c16ca04740 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740
;;; Fact-ids: Name Prims.warn_on_use; Namespace Prims
(assert (! (HasType Tm_arrow_2863eb88d7490a9c3cf347c16ca04740
Tm_type)
:named kinding_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.warn_on_use; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,36-235,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,36-235,40)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))
:qid Prims_pre_typing_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

:named Prims_pre_typing_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740
;;; Fact-ids: Name Prims.warn_on_use; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,36-235,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,36-235,40)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,36-235,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,36-235,40)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.string)
(HasType (ApplyTT @x0
@x1)
Prims.unit))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))
:qid Prims_interpretation_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

:named Prims_interpretation_Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))
(declare-fun Prims.warn_on_use@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.warn_on_use; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.warn_on_use@tok
@x0)
(Prims.warn_on_use @x0))
 

:pattern ((ApplyTT Prims.warn_on_use@tok
@x0))
:qid token_correspondence_Prims.warn_on_use))

:named token_correspondence_Prims.warn_on_use))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.warn_on_use; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.warn_on_use@tok
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.warn_on_use@tok
@x1)
(Prims.warn_on_use @x1))
 

:pattern ((Prims.warn_on_use @x1))
:qid function_token_typing_Prims.warn_on_use.1))
)
 

:pattern ((ApplyTT @x0
Prims.warn_on_use@tok))
:qid function_token_typing_Prims.warn_on_use))

:named function_token_typing_Prims.warn_on_use))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.warn_on_use; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(235,4-235,15)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (Prims.warn_on_use @x0)
Prims.unit))
 

:pattern ((Prims.warn_on_use @x0))
:qid typing_Prims.warn_on_use))

:named typing_Prims.warn_on_use))

; </end encoding Prims.warn_on_use>


; <Start encoding Prims.deprecated>

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

(declare-fun Prims.deprecated@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.deprecated; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.deprecated@tok
@x0)
(Prims.deprecated @x0))
 

:pattern ((ApplyTT Prims.deprecated@tok
@x0))
:qid token_correspondence_Prims.deprecated))

:named token_correspondence_Prims.deprecated))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.deprecated; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.deprecated@tok
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.deprecated@tok
@x1)
(Prims.deprecated @x1))
 

:pattern ((Prims.deprecated @x1))
:qid function_token_typing_Prims.deprecated.1))
)
 

:pattern ((ApplyTT @x0
Prims.deprecated@tok))
:qid function_token_typing_Prims.deprecated))

:named function_token_typing_Prims.deprecated))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.deprecated; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(241,4-241,14)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (Prims.deprecated @x0)
Prims.unit))
 

:pattern ((Prims.deprecated @x0))
:qid typing_Prims.deprecated))

:named typing_Prims.deprecated))

; </end encoding Prims.deprecated>


; <Start encoding Prims.has_type>

(declare-fun Prims.has_type (Term Term Term) Term)
;;;;;;;;;;;;;;;;_: a -> _: Type -> Type
(declare-fun Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b
;;; Fact-ids: Name Prims.has_type; Namespace Prims
(assert (! (HasType Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b
Tm_type)
:named kinding_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.has_type; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))
:qid Prims_pre_typing_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))

:named Prims_pre_typing_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b
;;; Fact-ids: Name Prims.has_type; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
Tm_type))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,41-260,46)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))
:qid Prims_interpretation_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))

:named Prims_interpretation_Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))
(declare-fun Prims.has_type@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.has_type; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.has_type@tok
@x0)
@x1)
@x2)
(Prims.has_type @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.has_type@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.has_type))

:named token_correspondence_Prims.has_type))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.has_type; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.has_type@tok
Tm_arrow_b5d8ed0243b8c7c893f2b329de57c62b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.has_type@tok
@x1)
@x2)
@x3)
(Prims.has_type @x1
@x2
@x3))
 

:pattern ((Prims.has_type @x1
@x2
@x3))
:qid function_token_typing_Prims.has_type.1))
)
 

:pattern ((ApplyTT @x0
Prims.has_type@tok))
:qid function_token_typing_Prims.has_type))

:named function_token_typing_Prims.has_type))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.has_type; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(260,5-260,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0)
(HasType @x2
Tm_type))
(HasType (Prims.has_type @x0
@x1
@x2)
Tm_type))
 

:pattern ((Prims.has_type @x0
@x1
@x2))
:qid typing_Prims.has_type))

:named typing_Prims.has_type))

; </end encoding Prims.has_type>


; <Start encoding Prims.l_Forall>

;;;;;;;;;;;;;;;;_: a -> Prims.GTot Type
(declare-fun Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)
Tm_type))
:qid kinding_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da))

:named kinding_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2)))
:qid Prims_pre_typing_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da))

:named Prims_pre_typing_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@x1)
(HasType (ApplyTT @x0
@x2)
Tm_type))
 

:pattern ((ApplyTT @x0
@x2))
:qid Prims_interpretation_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
:qid Prims_interpretation_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da))

:named Prims_interpretation_Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da))
(declare-fun Prims.l_Forall (Term Term) Term)

;;;;;;;;;;;;;;;;p: (_: a -> Prims.GTot Type) -> Prims.logical
(declare-fun Tm_arrow_977ec6901669a051ac66211b8e72666a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_977ec6901669a051ac66211b8e72666a
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! (HasType Tm_arrow_977ec6901669a051ac66211b8e72666a
Tm_type)
:named kinding_Tm_arrow_977ec6901669a051ac66211b8e72666a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_977ec6901669a051ac66211b8e72666a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_977ec6901669a051ac66211b8e72666a))
:qid Prims_pre_typing_Tm_arrow_977ec6901669a051ac66211b8e72666a))

:named Prims_pre_typing_Tm_arrow_977ec6901669a051ac66211b8e72666a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_977ec6901669a051ac66211b8e72666a
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_977ec6901669a051ac66211b8e72666a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_977ec6901669a051ac66211b8e72666a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_977ec6901669a051ac66211b8e72666a.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_977ec6901669a051ac66211b8e72666a))
:qid Prims_interpretation_Tm_arrow_977ec6901669a051ac66211b8e72666a))

:named Prims_interpretation_Tm_arrow_977ec6901669a051ac66211b8e72666a))
(declare-fun Prims.l_Forall@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_Forall@tok
@x0)
@x1)
(Prims.l_Forall @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.l_Forall@tok
@x0)
@x1))
:qid token_correspondence_Prims.l_Forall))

:named token_correspondence_Prims.l_Forall))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_Forall@tok
Tm_arrow_977ec6901669a051ac66211b8e72666a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_Forall@tok
@x1)
@x2)
(Prims.l_Forall @x1
@x2))
 

:pattern ((Prims.l_Forall @x1
@x2))
:qid function_token_typing_Prims.l_Forall.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_Forall@tok))
:qid function_token_typing_Prims.l_Forall))

:named function_token_typing_Prims.l_Forall))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)))
(HasType (Prims.l_Forall @x0
@x1)
Prims.logical))
 

:pattern ((Prims.l_Forall @x0
@x1))
:qid typing_Prims.l_Forall))

:named typing_Prims.l_Forall))

;;;;;;;;;;;;;;;;x: a -> Prims.GTot (p x)
(declare-fun Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x0
@x1)
Tm_type))
:qid kinding_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f))

:named kinding_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x2
@x3)))
:qid Prims_pre_typing_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f))

:named Prims_pre_typing_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f))
;;;;;;;;;;;;;;;;interpretation_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x1
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,81-265,86)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(HasType (ApplyTT @x0
@x3)
(ApplyTT @x1
@x3)))
 

:pattern ((ApplyTT @x0
@x3))
:qid Prims_interpretation_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f.1))
)
 

:pattern ((HasTypeZ @x0
(Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x1
@x2)))
:qid Prims_interpretation_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f))

:named Prims_interpretation_Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f))
;;;;;;;;;;;;;;;;Equation for Prims.l_Forall
;;; Fact-ids: Name Prims.l_Forall; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,5-265,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.l_Forall @x0
@x1)
(Prims.squash (Tm_ghost_arrow_3aa447697277bb40c9738c9125c3e80f @x1
@x0)))
 

:pattern ((Prims.l_Forall @x0
@x1))
:qid equation_Prims.l_Forall))

:named equation_Prims.l_Forall))

; </end encoding Prims.l_Forall>


; <Skipped />


; <Start encoding Prims.subtype_of>

(declare-fun Prims.subtype_of (Term Term) Term)
;;;;;;;;;;;;;;;;p1: Type -> p2: Type -> Prims.logical
(declare-fun Tm_arrow_28becc0427b69ebf63ea956148504d97 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_28becc0427b69ebf63ea956148504d97
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! (HasType Tm_arrow_28becc0427b69ebf63ea956148504d97
Tm_type)
:named kinding_Tm_arrow_28becc0427b69ebf63ea956148504d97))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,38-270,45)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_28becc0427b69ebf63ea956148504d97)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_28becc0427b69ebf63ea956148504d97))
:qid Prims_pre_typing_Tm_arrow_28becc0427b69ebf63ea956148504d97))

:named Prims_pre_typing_Tm_arrow_28becc0427b69ebf63ea956148504d97))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_28becc0427b69ebf63ea956148504d97
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,38-270,45)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_28becc0427b69ebf63ea956148504d97)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,38-270,45)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_28becc0427b69ebf63ea956148504d97.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,38-270,45)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_28becc0427b69ebf63ea956148504d97.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_28becc0427b69ebf63ea956148504d97))
:qid Prims_interpretation_Tm_arrow_28becc0427b69ebf63ea956148504d97))

:named Prims_interpretation_Tm_arrow_28becc0427b69ebf63ea956148504d97))
(declare-fun Prims.subtype_of@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.subtype_of@tok
@x0)
@x1)
(Prims.subtype_of @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.subtype_of@tok
@x0)
@x1))
:qid token_correspondence_Prims.subtype_of))

:named token_correspondence_Prims.subtype_of))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.subtype_of@tok
Tm_arrow_28becc0427b69ebf63ea956148504d97))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.subtype_of@tok
@x1)
@x2)
(Prims.subtype_of @x1
@x2))
 

:pattern ((Prims.subtype_of @x1
@x2))
:qid function_token_typing_Prims.subtype_of.1))
)
 

:pattern ((ApplyTT @x0
Prims.subtype_of@tok))
:qid function_token_typing_Prims.subtype_of))

:named function_token_typing_Prims.subtype_of))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,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))

(declare-fun Tm_abs_2319c8dded71dc14c3f65c301c18a7ca (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_2319c8dded71dc14c3f65c301c18a7ca
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x0
@x1)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
 

:pattern ((Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x0
@x1))
:qid typing_Tm_abs_2319c8dded71dc14c3f65c301c18a7ca))

:named typing_Tm_abs_2319c8dded71dc14c3f65c301c18a7ca))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_2319c8dded71dc14c3f65c301c18a7ca
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x1
@x2)
@x0)
(Prims.has_type @x2
@x0
@x1))
 

:pattern ((ApplyTT (Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x1
@x2)
@x0))
:qid interpretation_Tm_abs_2319c8dded71dc14c3f65c301c18a7ca))

:named interpretation_Tm_abs_2319c8dded71dc14c3f65c301c18a7ca))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.l_Forall @x1
(Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x0
@x1)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@x1)
(HasType @x2
@x0))
 
;;no pats
:qid l_quant_interp_5b2993f9f2c0eba3627049a3b4167c7a.1))
)
 

:pattern ((Valid (Prims.l_Forall @x1
(Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x0
@x1))))
:qid l_quant_interp_5b2993f9f2c0eba3627049a3b4167c7a))

:named l_quant_interp_5b2993f9f2c0eba3627049a3b4167c7a))
;;;;;;;;;;;;;;;;Equation for Prims.subtype_of
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Valid (Prims.subtype_of @x0
@x1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,31-270,60)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@x0)
(HasType @x2
@x1))
 
;;no pats
: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.subtype_of
;;; Fact-ids: Name Prims.subtype_of; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(270,4-270,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.subtype_of @x0
@x1)
(Prims.l_Forall @x0
(Tm_abs_2319c8dded71dc14c3f65c301c18a7ca @x1
@x0)))
 

:pattern ((Prims.subtype_of (Prims.subtype_of @x0
@x1)
Prims.unit))
:qid defn_equation_Prims.subtype_of))

:named defn_equation_Prims.subtype_of))

; </end encoding Prims.subtype_of>


; <Skipped />


; <Start encoding Prims.prop>

(declare-fun Prims.prop () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert (! (HasType Prims.prop
Tm_type)
:named function_token_typing_Prims.prop))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert (! (HasType Prims.prop
Tm_type)
:named typing_Prims.prop))
(declare-fun Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert (! (HasType Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf
Tm_type)
:named refinement_kinding_Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(283,12-283,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(283,12-283,41)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf)
(and (HasTypeFuel @u0
@x1
Tm_type)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(283,21-283,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(283,21-283,40)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(283,21-283,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(283,21-283,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))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Equation for Prims.prop
;;; Fact-ids: Name Prims.prop; Namespace Prims
(assert (! (= Prims.prop
Tm_refine_73f210ca6e0061ed4a3150f69b8f33bf)
:named equation_Prims.prop))

; </end encoding Prims.prop>


; <Start encoding Prims.range>

(declare-fun Prims.range () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.range; Namespace Prims
(assert (! (HasType Prims.range
Tm_type)
:named function_token_typing_Prims.range))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.range; Namespace Prims
(assert (! (= 232
(Term_constr_id Prims.range))
:named constructor_distinct_Prims.range))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.range; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(291,5-291,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(291,5-291,10)
(forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.range)
(= Prims.range
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
Prims.range))
:qid Prims_pretyping_cd1dd43c7849cf822e800878c71021f1))

:named Prims_pretyping_cd1dd43c7849cf822e800878c71021f1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.range; Namespace Prims
(assert (! (HasType Prims.range
Tm_type)
:named typing_Prims.range))
;;;;;;;;;;;;;;;;Range_const typing
;;; Fact-ids: Name Prims.range; Namespace Prims
(assert (! (HasTypeZ (Range_const 1)
Prims.range)
:named typing_range_const))

; </end encoding Prims.range>


; <Start encoding Prims.pure_pre>

(declare-fun Prims.pure_pre () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_pre; Namespace Prims
(assert (! (HasType Prims.pure_pre
Tm_type)
:named function_token_typing_Prims.pure_pre))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_pre; Namespace Prims
(assert (! (HasType Prims.pure_pre
Tm_type)
:named typing_Prims.pure_pre))
;;;;;;;;;;;;;;;;Equation for Prims.pure_pre
;;; Fact-ids: Name Prims.pure_pre; Namespace Prims
(assert (! (= Prims.pure_pre
Tm_type)
:named equation_Prims.pure_pre))

; </end encoding Prims.pure_pre>


; <Start encoding Prims.pure_post'>

(declare-fun Prims.pure_post_ (Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> pre: Type -> Type
(declare-fun Tm_arrow_e4cf09589736facd1137944a1f5a00a6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e4cf09589736facd1137944a1f5a00a6
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! (HasType Tm_arrow_e4cf09589736facd1137944a1f5a00a6
Tm_type)
:named kinding_Tm_arrow_e4cf09589736facd1137944a1f5a00a6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e4cf09589736facd1137944a1f5a00a6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))
:qid Prims_pre_typing_Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

:named Prims_pre_typing_Tm_arrow_e4cf09589736facd1137944a1f5a00a6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e4cf09589736facd1137944a1f5a00a6
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e4cf09589736facd1137944a1f5a00a6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_e4cf09589736facd1137944a1f5a00a6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,54)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_e4cf09589736facd1137944a1f5a00a6.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))
:qid Prims_interpretation_Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

:named Prims_interpretation_Tm_arrow_e4cf09589736facd1137944a1f5a00a6))
(declare-fun Prims.pure_post_@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.pure_post_@tok
@x0)
@x1)
(Prims.pure_post_ @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.pure_post_@tok
@x0)
@x1))
:qid token_correspondence_Prims.pure_post_))

:named token_correspondence_Prims.pure_post_))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_post_@tok
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.pure_post_@tok
@x1)
@x2)
(Prims.pure_post_ @x1
@x2))
 

:pattern ((Prims.pure_post_ @x1
@x2))
:qid function_token_typing_Prims.pure_post_.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_post_@tok))
:qid function_token_typing_Prims.pure_post_))

:named function_token_typing_Prims.pure_post_))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,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_))
(declare-fun Tm_refine_8d65e998a07dd53ec478e27017d9dba5 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,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_interpretation
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,18-302,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,36-302,39)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,18-302,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,36-302,39)
@x3
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_8d65e998a07dd53ec478e27017d9dba5))

:named refinement_interpretation_Tm_refine_8d65e998a07dd53ec478e27017d9dba5))
;;;;;;;;;;;;;;;;haseq for Tm_refine_8d65e998a07dd53ec478e27017d9dba5
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,31-302,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))
;;;;;;;;;;;;;;;;_: a{pre} -> Prims.GTot Type
(declare-fun Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,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))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,54)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,49-302,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))
;;;;;;;;;;;;;;;;Equation for Prims.pure_post'
;;; Fact-ids: Name Prims.pure_post'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(302,4-302,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_))

; </end encoding Prims.pure_post'>


; <Start encoding Prims.pure_post>

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

(declare-fun Prims.pure_post@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_post; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.pure_post@tok
@x0)
(Prims.pure_post @x0))
 

:pattern ((ApplyTT Prims.pure_post@tok
@x0))
:qid token_correspondence_Prims.pure_post))

:named token_correspondence_Prims.pure_post))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_post; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_post@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.pure_post@tok
@x1)
(Prims.pure_post @x1))
 

:pattern ((Prims.pure_post @x1))
:qid function_token_typing_Prims.pure_post.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_post@tok))
:qid function_token_typing_Prims.pure_post))

:named function_token_typing_Prims.pure_post))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_post; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,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))
;;;;;;;;;;;;;;;;Equation for Prims.pure_post
;;; Fact-ids: Name Prims.pure_post; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(303,4-303,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))

; </end encoding Prims.pure_post>


; <Start encoding Prims.pure_wp'>

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

(declare-fun Prims.pure_wp_@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.pure_wp_@tok
@x0)
(Prims.pure_wp_ @x0))
 

:pattern ((ApplyTT Prims.pure_wp_@tok
@x0))
:qid token_correspondence_Prims.pure_wp_))

:named token_correspondence_Prims.pure_wp_))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_wp_@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.pure_wp_@tok
@x1)
(Prims.pure_wp_ @x1))
 

:pattern ((Prims.pure_wp_ @x1))
:qid function_token_typing_Prims.pure_wp_.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_wp_@tok))
:qid function_token_typing_Prims.pure_wp_))

:named function_token_typing_Prims.pure_wp_))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.pure_wp_ @x0)
Tm_type))
 

:pattern ((Prims.pure_wp_ @x0))
:qid typing_Prims.pure_wp_))

:named typing_Prims.pure_wp_))
;;;;;;;;;;;;;;;;_: Prims.pure_post a -> Prims.GTot Prims.pure_pre
(declare-fun Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x0)
Tm_type))
:qid kinding_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4))

:named kinding_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x2)))
:qid Prims_pre_typing_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4))

:named Prims_pre_typing_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(Prims.pure_post @x1))
(HasType (ApplyTT @x0
@x2)
Prims.pure_pre))
 

:pattern ((ApplyTT @x0
@x2))
:qid Prims_interpretation_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x1)))
:qid Prims_interpretation_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4))

:named Prims_interpretation_Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4))
;;;;;;;;;;;;;;;;Equation for Prims.pure_wp'
;;; Fact-ids: Name Prims.pure_wp'; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,4-312,12)
(forall ((@x0 Term))
 (! (= (Prims.pure_wp_ @x0)
(Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x0))
 

:pattern ((Prims.pure_wp_ @x0))
:qid equation_Prims.pure_wp_))

:named equation_Prims.pure_wp_))

; </end encoding Prims.pure_wp'>


; <Start encoding Prims.pure_wp_monotonic0>

(declare-fun Prims.pure_wp_monotonic0 (Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> wp: Prims.pure_wp' a -> Prims.logical
(declare-fun Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! (HasType Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e
Tm_type)
:named kinding_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))
:qid Prims_pre_typing_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))

:named Prims_pre_typing_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Prims.pure_wp_ @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))
:qid Prims_interpretation_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))

:named Prims_interpretation_Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))
(declare-fun Prims.pure_wp_monotonic0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.pure_wp_monotonic0@tok
@x0)
@x1)
(Prims.pure_wp_monotonic0 @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.pure_wp_monotonic0@tok
@x0)
@x1))
:qid token_correspondence_Prims.pure_wp_monotonic0))

:named token_correspondence_Prims.pure_wp_monotonic0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_wp_monotonic0@tok
Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.pure_wp_monotonic0@tok
@x1)
@x2)
(Prims.pure_wp_monotonic0 @x1
@x2))
 

:pattern ((Prims.pure_wp_monotonic0 @x1
@x2))
:qid function_token_typing_Prims.pure_wp_monotonic0.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_wp_monotonic0@tok))
:qid function_token_typing_Prims.pure_wp_monotonic0))

:named function_token_typing_Prims.pure_wp_monotonic0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Prims.pure_wp_ @x0)))
(HasType (Prims.pure_wp_monotonic0 @x0
@x1)
Prims.logical))
 

:pattern ((Prims.pure_wp_monotonic0 @x0
@x1))
:qid typing_Prims.pure_wp_monotonic0))

:named typing_Prims.pure_wp_monotonic0))

(declare-fun Tm_abs_ea1703a99385b474600aa7a3bdb045c5 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_ea1703a99385b474600aa7a3bdb045c5
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x0
@x1
@x2)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2))
 

:pattern ((Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x0
@x1
@x2))
:qid typing_Tm_abs_ea1703a99385b474600aa7a3bdb045c5))

:named typing_Tm_abs_ea1703a99385b474600aa7a3bdb045c5))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_ea1703a99385b474600aa7a3bdb045c5
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x1
@x2
@x3)
@x0)
(Prims.l_imp (ApplyTT @x1
@x0)
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_ea1703a99385b474600aa7a3bdb045c5))

:named interpretation_Tm_abs_ea1703a99385b474600aa7a3bdb045c5))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall @x2
(Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46)
(ApplyTT @x1
@x3)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54)
(ApplyTT @x0
@x3)
)
)
 
;;no pats
:qid l_quant_interp_78041fc93dbf8b238989cd676a5806f6.1))
)
 

:pattern ((Valid (Prims.l_Forall @x2
(Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x1
@x0
@x2))))
:qid l_quant_interp_78041fc93dbf8b238989cd676a5806f6))

:named l_quant_interp_78041fc93dbf8b238989cd676a5806f6))
;;;;;;;;;;;;;;;;q: Prims.pure_post a -> Prims.GTot Type
(declare-fun Tm_arrow_b275e247a67e3e77d7c5997d864d1247 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b275e247a67e3e77d7c5997d864d1247
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x0)
Tm_type))
:qid kinding_Tm_arrow_b275e247a67e3e77d7c5997d864d1247))

:named kinding_Tm_arrow_b275e247a67e3e77d7c5997d864d1247))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x2)))
:qid Prims_pre_typing_Tm_arrow_b275e247a67e3e77d7c5997d864d1247))

:named Prims_pre_typing_Tm_arrow_b275e247a67e3e77d7c5997d864d1247))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b275e247a67e3e77d7c5997d864d1247
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,26)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(Prims.pure_post @x1))
(HasType (ApplyTT @x0
@x2)
Tm_type))
 

:pattern ((ApplyTT @x0
@x2))
:qid Prims_interpretation_Tm_arrow_b275e247a67e3e77d7c5997d864d1247.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x1)))
:qid Prims_interpretation_Tm_arrow_b275e247a67e3e77d7c5997d864d1247))

:named Prims_interpretation_Tm_arrow_b275e247a67e3e77d7c5997d864d1247))
(declare-fun Tm_abs_fd5475515272d0f1ce55fa6741fae069 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_fd5475515272d0f1ce55fa6741fae069
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_fd5475515272d0f1ce55fa6741fae069 @x0
@x1
@x2)
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x2))
 

:pattern ((Tm_abs_fd5475515272d0f1ce55fa6741fae069 @x0
@x1
@x2))
:qid typing_Tm_abs_fd5475515272d0f1ce55fa6741fae069))

:named typing_Tm_abs_fd5475515272d0f1ce55fa6741fae069))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_fd5475515272d0f1ce55fa6741fae069
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_fd5475515272d0f1ce55fa6741fae069 @x1
@x2
@x3)
@x0)
(Prims.l_imp (Prims.l_Forall @x3
(Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x1
@x0
@x3))
(Prims.l_imp (ApplyTT @x2
@x1)
(ApplyTT @x2
@x0))))
 

:pattern ((ApplyTT (Tm_abs_fd5475515272d0f1ce55fa6741fae069 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_fd5475515272d0f1ce55fa6741fae069))

:named interpretation_Tm_abs_fd5475515272d0f1ce55fa6741fae069))

(declare-fun Tm_abs_a590ae03fb5fe4509368585c8f8c00cd (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_a590ae03fb5fe4509368585c8f8c00cd
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x0
@x1)
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x1))
 

:pattern ((Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x0
@x1))
:qid typing_Tm_abs_a590ae03fb5fe4509368585c8f8c00cd))

:named typing_Tm_abs_a590ae03fb5fe4509368585c8f8c00cd))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_a590ae03fb5fe4509368585c8f8c00cd
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,9-321,75)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x1
@x2)
@x0)
(Prims.l_Forall (Prims.pure_post @x2)
(Tm_abs_fd5475515272d0f1ce55fa6741fae069 @x0
@x1
@x2)))
 

:pattern ((ApplyTT (Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x1
@x2)
@x0))
:qid interpretation_Tm_abs_a590ae03fb5fe4509368585c8f8c00cd))

:named interpretation_Tm_abs_a590ae03fb5fe4509368585c8f8c00cd))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,2-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,2-321,75)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.l_Forall (Prims.pure_post @x1)
(Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x0
@x1)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,2-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,2-321,75)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
(Prims.pure_post @x1))
(HasType @x3
(Prims.pure_post @x1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55)
(forall ((@x4 Term))
 (! (implies (and (HasType @x4
@x1)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46)
(ApplyTT @x2
@x4)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54)
(ApplyTT @x3
@x4)
)
)
 
;;no pats
:qid l_quant_interp_71257c228512ceaa84671e7dd2ff0073.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65)
(ApplyTT @x0
@x2)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74)
(ApplyTT @x0
@x3)
)
)
 
;;no pats
:qid l_quant_interp_71257c228512ceaa84671e7dd2ff0073.1))
)
 

:pattern ((Valid (Prims.l_Forall (Prims.pure_post @x1)
(Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x0
@x1))))
:qid l_quant_interp_71257c228512ceaa84671e7dd2ff0073))

:named l_quant_interp_71257c228512ceaa84671e7dd2ff0073))
;;;;;;;;;;;;;;;;Equation for Prims.pure_wp_monotonic0
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Valid (Prims.pure_wp_monotonic0 @x0
@x1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,2-321,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,2-321,75)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
(Prims.pure_post @x0))
(HasType @x3
(Prims.pure_post @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,28-321,55)
(forall ((@x4 Term))
 (! (implies (and (HasType @x4
@x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,43-321,46)
(ApplyTT @x2
@x4)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,51-321,54)
(ApplyTT @x3
@x4)
)
)
 
;;no pats
:qid equation_Prims.pure_wp_monotonic0.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,61-321,65)
(ApplyTT @x1
@x2)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(321,70-321,74)
(ApplyTT @x1
@x3)
)
)
 
;;no pats
:qid equation_Prims.pure_wp_monotonic0.1))
)
 

:pattern ((Prims.pure_wp_monotonic0 @x0
@x1))
:qid equation_Prims.pure_wp_monotonic0))

:named equation_Prims.pure_wp_monotonic0))
;;;;;;;;;;;;;;;;Equation for Prims.pure_wp_monotonic0
;;; Fact-ids: Name Prims.pure_wp_monotonic0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(320,4-320,22)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.pure_wp_monotonic0 @x0
@x1)
(Prims.l_Forall (Prims.pure_post @x0)
(Tm_abs_a590ae03fb5fe4509368585c8f8c00cd @x1
@x0)))
 

:pattern ((Prims.subtype_of (Prims.pure_wp_monotonic0 @x0
@x1)
Prims.unit))
:qid defn_equation_Prims.pure_wp_monotonic0))

:named defn_equation_Prims.pure_wp_monotonic0))

; </end encoding Prims.pure_wp_monotonic0>


; <Start encoding Prims.pure_wp_monotonic>

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

(declare-fun Prims.pure_wp_monotonic@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_wp_monotonic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.pure_wp_monotonic@tok
@x0)
@x1)
(Prims.pure_wp_monotonic @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.pure_wp_monotonic@tok
@x0)
@x1))
:qid token_correspondence_Prims.pure_wp_monotonic))

:named token_correspondence_Prims.pure_wp_monotonic))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_wp_monotonic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_wp_monotonic@tok
Tm_arrow_85436e2c1c64a4dd0159a737ef5b212e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.pure_wp_monotonic@tok
@x1)
@x2)
(Prims.pure_wp_monotonic @x1
@x2))
 

:pattern ((Prims.pure_wp_monotonic @x1
@x2))
:qid function_token_typing_Prims.pure_wp_monotonic.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_wp_monotonic@tok))
:qid function_token_typing_Prims.pure_wp_monotonic))

:named function_token_typing_Prims.pure_wp_monotonic))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_wp_monotonic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(324,4-324,21)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Prims.pure_wp_ @x0)))
(HasType (Prims.pure_wp_monotonic @x0
@x1)
Prims.logical))
 

:pattern ((Prims.pure_wp_monotonic @x0
@x1))
:qid typing_Prims.pure_wp_monotonic))

:named typing_Prims.pure_wp_monotonic))

; </end encoding Prims.pure_wp_monotonic>


; <Start encoding Prims.pure_wp>

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

(declare-fun Prims.pure_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.pure_wp@tok
@x0)
(Prims.pure_wp @x0))
 

:pattern ((ApplyTT Prims.pure_wp@tok
@x0))
:qid token_correspondence_Prims.pure_wp))

:named token_correspondence_Prims.pure_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_wp@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.pure_wp@tok
@x1)
(Prims.pure_wp @x1))
 

:pattern ((Prims.pure_wp @x1))
:qid function_token_typing_Prims.pure_wp.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_wp@tok))
:qid function_token_typing_Prims.pure_wp))

:named function_token_typing_Prims.pure_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.pure_wp @x0)
Tm_type))
 

:pattern ((Prims.pure_wp @x0))
:qid typing_Prims.pure_wp))

:named typing_Prims.pure_wp))
(declare-fun Tm_refine_15e0beb75f7033bad5fae236999feebe (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,24-326,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,24-326,61)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_15e0beb75f7033bad5fae236999feebe @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_15e0beb75f7033bad5fae236999feebe @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_15e0beb75f7033bad5fae236999feebe))

:named refinement_kinding_Tm_refine_15e0beb75f7033bad5fae236999feebe))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,24-326,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,24-326,61)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_15e0beb75f7033bad5fae236999feebe @x2))
(and (HasTypeFuel @u0
@x1
(Prims.pure_wp_ @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,38-326,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,38-326,60)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,38-326,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,38-326,60)
(Prims.pure_wp_monotonic @x2
@x1)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_15e0beb75f7033bad5fae236999feebe @x2)))
:qid refinement_interpretation_Tm_refine_15e0beb75f7033bad5fae236999feebe))

:named refinement_interpretation_Tm_refine_15e0beb75f7033bad5fae236999feebe))
;;;;;;;;;;;;;;;;haseq for Tm_refine_15e0beb75f7033bad5fae236999feebe
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,24-326,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,24-326,61)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_15e0beb75f7033bad5fae236999feebe @x0)))
(Valid (Prims.hasEq (Prims.pure_wp_ @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_15e0beb75f7033bad5fae236999feebe @x0))))
:qid haseqTm_refine_15e0beb75f7033bad5fae236999feebe))

:named haseqTm_refine_15e0beb75f7033bad5fae236999feebe))
;;;;;;;;;;;;;;;;Equation for Prims.pure_wp
;;; Fact-ids: Name Prims.pure_wp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(326,4-326,11)
(forall ((@x0 Term))
 (! (= (Prims.pure_wp @x0)
(Tm_refine_15e0beb75f7033bad5fae236999feebe @x0))
 

:pattern ((Prims.pure_wp @x0))
:qid equation_Prims.pure_wp))

:named equation_Prims.pure_wp))

; </end encoding Prims.pure_wp>


; <Start encoding Prims.guard_free>

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

(declare-fun Prims.guard_free@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.guard_free; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.guard_free@tok
@x0)
(Prims.guard_free @x0))
 

:pattern ((ApplyTT Prims.guard_free@tok
@x0))
:qid token_correspondence_Prims.guard_free))

:named token_correspondence_Prims.guard_free))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.guard_free; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.guard_free@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.guard_free@tok
@x1)
(Prims.guard_free @x1))
 

:pattern ((Prims.guard_free @x1))
:qid function_token_typing_Prims.guard_free.1))
)
 

:pattern ((ApplyTT @x0
Prims.guard_free@tok))
:qid function_token_typing_Prims.guard_free))

:named function_token_typing_Prims.guard_free))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.guard_free; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(333,5-333,15)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.guard_free @x0)
Tm_type))
 

:pattern ((Prims.guard_free @x0))
:qid typing_Prims.guard_free))

:named typing_Prims.guard_free))

; </end encoding Prims.guard_free>


; <Skipped Prims.pure_return0/>


; <Skipped Prims.pure_bind_wp0/>


; <Skipped Prims.pure_if_then_else0/>


; <Skipped Prims.pure_ite_wp0/>


; <Skipped Prims.pure_stronger/>


; <Skipped Prims.pure_close_wp0/>


; <Skipped Prims.pure_trivial/>


; <Skipped Prims.PURE/>


; <Skipped Prims.Pure/>


; <Skipped Prims.Admit/>


; <Skipped Prims.pure_null_wp0/>


; <Skipped Prims.Tot/>


; <Start encoding Prims.pure_assert_wp0>

(declare-fun Prims.pure_assert_wp0 (Term) Term)
;;;;;;;;;;;;;;;;p: Type -> Prims.pure_wp Prims.unit
(declare-fun Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67
;;; Fact-ids: Name Prims.pure_assert_wp0; Namespace Prims
(assert (! (HasType Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67
Tm_type)
:named kinding_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pure_assert_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,32-446,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,32-446,44)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))
:qid Prims_pre_typing_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))

:named Prims_pre_typing_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67
;;; Fact-ids: Name Prims.pure_assert_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,32-446,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,32-446,44)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,32-446,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,32-446,44)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
(Prims.pure_wp Prims.unit)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))
:qid Prims_interpretation_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))

:named Prims_interpretation_Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))
(declare-fun Prims.pure_assert_wp0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_assert_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.pure_assert_wp0@tok
@x0)
(Prims.pure_assert_wp0 @x0))
 

:pattern ((ApplyTT Prims.pure_assert_wp0@tok
@x0))
:qid token_correspondence_Prims.pure_assert_wp0))

:named token_correspondence_Prims.pure_assert_wp0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_assert_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_assert_wp0@tok
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.pure_assert_wp0@tok
@x1)
(Prims.pure_assert_wp0 @x1))
 

:pattern ((Prims.pure_assert_wp0 @x1))
:qid function_token_typing_Prims.pure_assert_wp0.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_assert_wp0@tok))
:qid function_token_typing_Prims.pure_assert_wp0))

:named function_token_typing_Prims.pure_assert_wp0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_assert_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,4-446,19)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.pure_assert_wp0 @x0)
(Prims.pure_wp Prims.unit)))
 

:pattern ((Prims.pure_assert_wp0 @x0))
:qid typing_Prims.pure_assert_wp0))

:named typing_Prims.pure_assert_wp0))

; </end encoding Prims.pure_assert_wp0>


; <Start encoding Prims.pure_assume_wp0>

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

(declare-fun Prims.pure_assume_wp0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pure_assume_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.pure_assume_wp0@tok
@x0)
(Prims.pure_assume_wp0 @x0))
 

:pattern ((ApplyTT Prims.pure_assume_wp0@tok
@x0))
:qid token_correspondence_Prims.pure_assume_wp0))

:named token_correspondence_Prims.pure_assume_wp0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pure_assume_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pure_assume_wp0@tok
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.pure_assume_wp0@tok
@x1)
(Prims.pure_assume_wp0 @x1))
 

:pattern ((Prims.pure_assume_wp0 @x1))
:qid function_token_typing_Prims.pure_assume_wp0.1))
)
 

:pattern ((ApplyTT @x0
Prims.pure_assume_wp0@tok))
:qid function_token_typing_Prims.pure_assume_wp0))

:named function_token_typing_Prims.pure_assume_wp0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pure_assume_wp0; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(451,4-451,19)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.pure_assume_wp0 @x0)
(Prims.pure_wp Prims.unit)))
 

:pattern ((Prims.pure_assume_wp0 @x0))
:qid typing_Prims.pure_assume_wp0))

:named typing_Prims.pure_assume_wp0))

; </end encoding Prims.pure_assume_wp0>


; <Skipped Prims.GHOST/>


; <Skipped Prims.purewp_id/>


; <Skipped />


; <Skipped Prims.Ghost/>


; <Skipped Prims.GTot/>


; <Start encoding Prims.op_Equals_Equals_Equals>

(declare-fun Prims.op_Equals_Equals_Equals (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> y: b -> Prims.logical
(declare-fun Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! (HasType Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9
Tm_type)
:named kinding_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))
:qid Prims_pre_typing_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))

:named Prims_pre_typing_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1)
(HasType @x4
@x2))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid Prims_interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,42-485,49)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))
:qid Prims_interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))

:named Prims_interpretation_Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))
(declare-fun Prims.op_Equals_Equals_Equals@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.op_Equals_Equals_Equals@tok
@x0)
@x1)
@x2)
@x3)
(Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.op_Equals_Equals_Equals@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_Prims.op_Equals_Equals_Equals))

:named token_correspondence_Prims.op_Equals_Equals_Equals))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.op_Equals_Equals_Equals@tok
Tm_arrow_7fcb145b23c2ac843afd9b126c4f71a9))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.op_Equals_Equals_Equals@tok
@x1)
@x2)
@x3)
@x4)
(Prims.op_Equals_Equals_Equals @x1
@x2
@x3
@x4))
 

:pattern ((Prims.op_Equals_Equals_Equals @x1
@x2
@x3
@x4))
:qid function_token_typing_Prims.op_Equals_Equals_Equals.1))
)
 

:pattern ((ApplyTT @x0
Prims.op_Equals_Equals_Equals@tok))
:qid function_token_typing_Prims.op_Equals_Equals_Equals))

:named function_token_typing_Prims.op_Equals_Equals_Equals))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
@x0)
(HasType @x3
@x1))
(HasType (Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3)
Prims.logical))
 

:pattern ((Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3))
:qid typing_Prims.op_Equals_Equals_Equals))

:named typing_Prims.op_Equals_Equals_Equals))
;;;;;;;;;;;;;;;;Equation for Prims.op_Equals_Equals_Equals
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Valid (Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,52-485,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,52-485,68)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,52-485,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,52-485,58)
(= @x0
@x1)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,62-485,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,62-485,68)
(= @x2
@x3)
)
)
 

:pattern ((Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3))
:qid equation_Prims.op_Equals_Equals_Equals))

:named equation_Prims.op_Equals_Equals_Equals))
;;;;;;;;;;;;;;;;Equation for Prims.op_Equals_Equals_Equals
;;; Fact-ids: Name Prims.op_Equals_Equals_Equals; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(485,6-485,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3)
(Prims.l_and (Prims.eq2 Tm_type
@x0
@x1)
(Prims.eq2 @x0
@x2
@x3)))
 

:pattern ((Prims.subtype_of (Prims.op_Equals_Equals_Equals @x0
@x1
@x2
@x3)
Prims.unit))
:qid defn_equation_Prims.op_Equals_Equals_Equals))

:named defn_equation_Prims.op_Equals_Equals_Equals))

; </end encoding Prims.op_Equals_Equals_Equals>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.dtuple2 (Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.dtuple2@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.dtuple2@x1 (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: Mkdtuple2
(declare-fun Prims.Mkdtuple2@tok () Term)



;;;;;;;;;;;;;;;;_1: a -> _2: b _1 -> Prims.dtuple2 a b
(declare-fun Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! (HasType Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b
Tm_type)
:named kinding_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))
:qid Prims_pre_typing_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))

:named Prims_pre_typing_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
@x1)
(HasType @x4
(ApplyTT @x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Prims.dtuple2 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid Prims_interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,37-491,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))
:qid Prims_interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))

:named Prims_interpretation_Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))

; <Start encoding Prims.dtuple2>


; <start constructor Prims.dtuple2>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= 269
(Term_constr_id (Prims.dtuple2 @x0
@x1)))
 

:pattern ((Prims.dtuple2 @x0
@x1))
:qid constructor_distinct_Prims.dtuple2))

:named constructor_distinct_Prims.dtuple2))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.dtuple2 ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
269)
(exists ((@x0 Term) (@x1 Term))
 (! (= __@x0
(Prims.dtuple2 @x0
@x1))
 
;;no pats
:qid is-Prims.dtuple2))))

; </end constructor Prims.dtuple2>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! (= 270
(Term_constr_id Prims.dtuple2@tok))
:named fresh_token_Prims.dtuple2@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.dtuple2@tok
@x0)
@x1)
(Prims.dtuple2 @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.dtuple2@tok
@x0)
@x1))

:pattern ((Prims.dtuple2 @x0
@x1))
:qid token_correspondence_Prims.dtuple2@tok))

:named token_correspondence_Prims.dtuple2@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! (is-Tm_arrow (PreType Prims.dtuple2@tok))
:named pre_kinding_Prims.dtuple2@tok))
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! (and (IsTotFun Prims.dtuple2@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.dtuple2@tok
@x0))
 

:pattern ((ApplyTT Prims.dtuple2@tok
@x0))
:qid kinding_Prims.dtuple2@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)))
(HasType (Prims.dtuple2 @x0
@x1)
Tm_type))
 

:pattern ((Prims.dtuple2 @x0
@x1))
:qid kinding_Prims.dtuple2@tok.1))
)
:named kinding_Prims.dtuple2@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.dtuple2 @x2
@x3))
(= (Prims.dtuple2 @x2
@x3)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(Prims.dtuple2 @x2
@x3)))
:qid Prims_pretyping_09d9235a8068627898e77b75945bdc5c))

:named Prims_pretyping_09d9235a8068627898e77b75945bdc5c))

; </end encoding Prims.dtuple2>


; <Start encoding Prims.Mkdtuple2>


; <start constructor Prims.Mkdtuple2>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= 278
(Term_constr_id (Prims.Mkdtuple2 @x0
@x1
@x2
@x3)))
 

:pattern ((Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
:qid constructor_distinct_Prims.Mkdtuple2))

:named constructor_distinct_Prims.Mkdtuple2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Mkdtuple2_a (Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
@x0)
 

:pattern ((Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Mkdtuple2_a))

:named projection_inverse_Prims.Mkdtuple2_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Mkdtuple2_b (Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
@x1)
 

:pattern ((Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Mkdtuple2_b))

:named projection_inverse_Prims.Mkdtuple2_b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Mkdtuple2__1 (Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
@x2)
 

:pattern ((Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Mkdtuple2__1))

:named projection_inverse_Prims.Mkdtuple2__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Prims.Mkdtuple2__2 (Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
@x3)
 

:pattern ((Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_Prims.Mkdtuple2__2))

:named projection_inverse_Prims.Mkdtuple2__2))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Mkdtuple2 ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
278)
(= __@x0
(Prims.Mkdtuple2 (Prims.Mkdtuple2_a __@x0)
(Prims.Mkdtuple2_b __@x0)
(Prims.Mkdtuple2__1 __@x0)
(Prims.Mkdtuple2__2 __@x0)))))

; </end constructor Prims.Mkdtuple2>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! (= 283
(Term_constr_id Prims.Mkdtuple2@tok))
:named fresh_token_Prims.Mkdtuple2@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Mkdtuple2@tok
Tm_arrow_22a50f5c5c9bb74bac4384fb8999be8b))
 

:pattern ((ApplyTT Prims.Mkdtuple2@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Mkdtuple2@tok))
:qid typing_tok_Prims.Mkdtuple2@tok))

:named typing_tok_Prims.Mkdtuple2@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Mkdtuple2@tok
@x0)
@x1)
@x2)
@x3)
(Prims.Mkdtuple2 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Mkdtuple2@tok
@x0)
@x1)
@x2)
@x3))
:qid equality_tok_Prims.Mkdtuple2@tok))

:named equality_tok_Prims.Mkdtuple2@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
@x1)
(HasTypeFuel @u0
@x4
(ApplyTT @x2
@x3)))
(HasTypeFuel @u0
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)
(Prims.dtuple2 @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)
(Prims.dtuple2 @x1
@x2)))
:qid data_typing_intro_Prims.Mkdtuple2@tok))

:named data_typing_intro_Prims.Mkdtuple2@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)
(Prims.dtuple2 @x5
@x6))
(and (HasTypeFuel @u0
@x6
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x4
(ApplyTT @x6
@x3))
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x5))
(HasTypeFuel @u0
@x3
@x5)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
@x1)
(HasTypeFuel @u0
@x4
(ApplyTT @x2
@x3))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)
(Prims.dtuple2 @x5
@x6)))
:qid data_elim_Prims.Mkdtuple2))

:named data_elim_Prims.Mkdtuple2))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)
(Prims.dtuple2 @x5
@x6))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x4
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Mkdtuple2 @x1
@x2
@x3
@x4)
(Prims.dtuple2 @x5
@x6)))
:qid subterm_ordering_Prims.Mkdtuple2))

:named subterm_ordering_Prims.Mkdtuple2))

; </end encoding Prims.Mkdtuple2>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.dtuple2; Namespace Prims; Name Prims.Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,5-490,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Prims.dtuple2 @x2
@x3))
(and (is-Prims.Mkdtuple2 @x1)
(= @x2
(Prims.Mkdtuple2_a @x1))
(= @x3
(Prims.Mkdtuple2_b @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(Prims.dtuple2 @x2
@x3)))
:qid fuel_guarded_inversion_Prims.dtuple2))

:named fuel_guarded_inversion_Prims.dtuple2))

; </end encoding >


; <Start encoding Prims.dtuple2__uu___haseq>


;;;;;;;;;;;;;;;;Assumption: dtuple2__uu___haseq
;;; Fact-ids: Name Prims.dtuple2__uu___haseq; Namespace Prims
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
@x0)
(HasType @x3
(ApplyTT @x1
@x2)))
(and (Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq (ApplyTT @x1
@x2)))))
 
;;no pats
:qid assumption_Prims.dtuple2__uu___haseq.1)))
(Valid (Prims.hasEq (Prims.dtuple2 @x0
@x1))))
 

:pattern ((Prims.hasEq (Prims.dtuple2 @x0
@x1)))
:qid assumption_Prims.dtuple2__uu___haseq))
:named assumption_Prims.dtuple2__uu___haseq))

; </end encoding Prims.dtuple2__uu___haseq>


; <Start encoding Prims.uu___is_Mkdtuple2>


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

;;;;;;;;;;;;;;;;projectee: Prims.dtuple2 a b -> Prims.bool
(declare-fun Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! (HasType Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc
Tm_type)
:named kinding_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
:qid Prims_pre_typing_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
:named Prims_pre_typing_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Prims.dtuple2 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc.3))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
:qid Prims_interpretation_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
:named Prims_interpretation_Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))
(declare-fun Prims.uu___is_Mkdtuple2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Mkdtuple2@tok
@x0)
@x1)
@x2)
(Prims.uu___is_Mkdtuple2 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Mkdtuple2@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.uu___is_Mkdtuple2))

:named token_correspondence_Prims.uu___is_Mkdtuple2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Mkdtuple2@tok
Tm_arrow_e6f9f7cb1936ec43b52469e706dcadcc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.uu___is_Mkdtuple2@tok
@x1)
@x2)
@x3)
(Prims.uu___is_Mkdtuple2 @x1
@x2
@x3))
 

:pattern ((Prims.uu___is_Mkdtuple2 @x1
@x2
@x3))
:qid function_token_typing_Prims.uu___is_Mkdtuple2.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Mkdtuple2@tok))
:qid function_token_typing_Prims.uu___is_Mkdtuple2))

:named function_token_typing_Prims.uu___is_Mkdtuple2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Prims.dtuple2 @x0
@x1)))
(HasType (Prims.uu___is_Mkdtuple2 @x0
@x1
@x2)
Prims.bool))
 

:pattern ((Prims.uu___is_Mkdtuple2 @x0
@x1
@x2))
:qid typing_Prims.uu___is_Mkdtuple2))

:named typing_Prims.uu___is_Mkdtuple2))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Mkdtuple2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,4-491,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.uu___is_Mkdtuple2 @x0
@x1
@x2)
(BoxBool (is-Prims.Mkdtuple2 @x2)))
 

:pattern ((Prims.uu___is_Mkdtuple2 @x0
@x1
@x2))
:qid disc_equation_Prims.Mkdtuple2))

:named disc_equation_Prims.Mkdtuple2))

; </end encoding Prims.uu___is_Mkdtuple2>


; <Skipped Prims.uu___is_Mkdtuple2/>


; <Start encoding Prims.__proj__Mkdtuple2__item___1>


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

;;;;;;;;;;;;;;;;projectee: Prims.dtuple2 a b -> a
(declare-fun Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! (HasType Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22
Tm_type)
:named kinding_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))
:qid Prims_pre_typing_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))

:named Prims_pre_typing_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Prims.dtuple2 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(490,14-490,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))
:qid Prims_interpretation_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))

:named Prims_interpretation_Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))
(declare-fun Prims.__proj__Mkdtuple2__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Mkdtuple2__item___1@tok
@x0)
@x1)
@x2)
(Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.__proj__Mkdtuple2__item___1@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.__proj__Mkdtuple2__item___1))

:named token_correspondence_Prims.__proj__Mkdtuple2__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Mkdtuple2__item___1@tok
Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Mkdtuple2__item___1@tok
@x1)
@x2)
@x3)
(Prims.__proj__Mkdtuple2__item___1 @x1
@x2
@x3))
 

:pattern ((Prims.__proj__Mkdtuple2__item___1 @x1
@x2
@x3))
:qid function_token_typing_Prims.__proj__Mkdtuple2__item___1.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Mkdtuple2__item___1@tok))
:qid function_token_typing_Prims.__proj__Mkdtuple2__item___1))

:named function_token_typing_Prims.__proj__Mkdtuple2__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Prims.dtuple2 @x0
@x1)))
(HasType (Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2)
@x0))
 

:pattern ((Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2))
:qid typing_Prims.__proj__Mkdtuple2__item___1))

:named typing_Prims.__proj__Mkdtuple2__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___1; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,16-491,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2)
(Prims.Mkdtuple2__1 @x2))
 

:pattern ((Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2))
:qid proj_equation_Prims.Mkdtuple2__1))

:named proj_equation_Prims.Mkdtuple2__1))

; </end encoding Prims.__proj__Mkdtuple2__item___1>


; <Skipped Prims.__proj__Mkdtuple2__item___1/>


; <Start encoding Prims.__proj__Mkdtuple2__item___2>


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

;;;;;;;;;;;;;;;;projectee: Prims.dtuple2 a b -> b (Mkdtuple2?._1 projectee)
(declare-fun Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! (HasType Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66
Tm_type)
:named kinding_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))
:qid Prims_pre_typing_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))

:named Prims_pre_typing_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Prims.dtuple2 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(ApplyTT @x2
(Prims.__proj__Mkdtuple2__item___1 @x1
@x2
@x3))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,29-491,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))
:qid Prims_interpretation_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))

:named Prims_interpretation_Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))
(declare-fun Prims.__proj__Mkdtuple2__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Mkdtuple2__item___2@tok
@x0)
@x1)
@x2)
(Prims.__proj__Mkdtuple2__item___2 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.__proj__Mkdtuple2__item___2@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.__proj__Mkdtuple2__item___2))

:named token_correspondence_Prims.__proj__Mkdtuple2__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Mkdtuple2__item___2@tok
Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.__proj__Mkdtuple2__item___2@tok
@x1)
@x2)
@x3)
(Prims.__proj__Mkdtuple2__item___2 @x1
@x2
@x3))
 

:pattern ((Prims.__proj__Mkdtuple2__item___2 @x1
@x2
@x3))
:qid function_token_typing_Prims.__proj__Mkdtuple2__item___2.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Mkdtuple2__item___2@tok))
:qid function_token_typing_Prims.__proj__Mkdtuple2__item___2))

:named function_token_typing_Prims.__proj__Mkdtuple2__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Prims.dtuple2 @x0
@x1)))
(HasType (Prims.__proj__Mkdtuple2__item___2 @x0
@x1
@x2)
(ApplyTT @x1
(Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2))))
 

:pattern ((Prims.__proj__Mkdtuple2__item___2 @x0
@x1
@x2))
:qid typing_Prims.__proj__Mkdtuple2__item___2))

:named typing_Prims.__proj__Mkdtuple2__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Mkdtuple2__item___2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(491,25-491,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.__proj__Mkdtuple2__item___2 @x0
@x1
@x2)
(Prims.Mkdtuple2__2 @x2))
 

:pattern ((Prims.__proj__Mkdtuple2__item___2 @x0
@x1
@x2))
:qid proj_equation_Prims.Mkdtuple2__2))

:named proj_equation_Prims.Mkdtuple2__2))

; </end encoding Prims.__proj__Mkdtuple2__item___2>


; <Skipped Prims.__proj__Mkdtuple2__item___2/>


; <Start encoding Prims.l_Exists>


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


(declare-fun Prims.l_Exists@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.l_Exists; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_Exists@tok
@x0)
@x1)
(Prims.l_Exists @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.l_Exists@tok
@x0)
@x1))
:qid token_correspondence_Prims.l_Exists))

:named token_correspondence_Prims.l_Exists))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.l_Exists; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.l_Exists@tok
Tm_arrow_977ec6901669a051ac66211b8e72666a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.l_Exists@tok
@x1)
@x2)
(Prims.l_Exists @x1
@x2))
 

:pattern ((Prims.l_Exists @x1
@x2))
:qid function_token_typing_Prims.l_Exists.1))
)
 

:pattern ((ApplyTT @x0
Prims.l_Exists@tok))
:qid function_token_typing_Prims.l_Exists))

:named function_token_typing_Prims.l_Exists))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.l_Exists; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)))
(HasType (Prims.l_Exists @x0
@x1)
Prims.logical))
 

:pattern ((Prims.l_Exists @x0
@x1))
:qid typing_Prims.l_Exists))

:named typing_Prims.l_Exists))


(declare-fun Tm_abs_6ba36691ee58dee85cd144324b083848 (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_6ba36691ee58dee85cd144324b083848
;;; Fact-ids: Name Prims.l_Exists; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,75-496,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,75-496,78)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_6ba36691ee58dee85cd144324b083848 @x0
@x1)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
 

:pattern ((Tm_abs_6ba36691ee58dee85cd144324b083848 @x0
@x1))
:qid typing_Tm_abs_6ba36691ee58dee85cd144324b083848))

:named typing_Tm_abs_6ba36691ee58dee85cd144324b083848))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_6ba36691ee58dee85cd144324b083848
;;; Fact-ids: Name Prims.l_Exists; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,75-496,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,75-496,78)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_6ba36691ee58dee85cd144324b083848 @x1
@x2)
@x0)
(ApplyTT @x1
@x0))
 

:pattern ((ApplyTT (Tm_abs_6ba36691ee58dee85cd144324b083848 @x1
@x2)
@x0))
:qid interpretation_Tm_abs_6ba36691ee58dee85cd144324b083848))

:named interpretation_Tm_abs_6ba36691ee58dee85cd144324b083848))
;;;;;;;;;;;;;;;;Equation for Prims.l_Exists
;;; Fact-ids: Name Prims.l_Exists; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,5-496,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.l_Exists @x0
@x1)
(Prims.squash (Prims.dtuple2 @x0
(Tm_abs_6ba36691ee58dee85cd144324b083848 @x1
@x0))))
 

:pattern ((Prims.l_Exists @x0
@x1))
:qid equation_Prims.l_Exists))

:named equation_Prims.l_Exists))

; </end encoding Prims.l_Exists>


; <Start encoding Prims.int>

(declare-fun Prims.int () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert (! (HasType Prims.int
Prims.eqtype)
:named function_token_typing_Prims.int))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert (! (= 314
(Term_constr_id Prims.int))
:named constructor_distinct_Prims.int))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(501,5-501,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(501,5-501,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))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.int; Namespace Prims
(assert (! (HasType Prims.int
Prims.eqtype)
:named typing_Prims.int))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;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))

; </end encoding Prims.int>


; <Start encoding Prims.range_0>

(declare-fun Prims.range_0 () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.range_0; Namespace Prims
(assert (! (HasType Prims.range_0
Prims.range)
:named function_token_typing_Prims.range_0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.range_0; Namespace Prims
(assert (! (HasType Prims.range_0
Prims.range)
:named typing_Prims.range_0))

; </end encoding Prims.range_0>


; <Start encoding Prims.mk_range>

(declare-fun Prims.mk_range (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;file: Prims.string ->     from_line: Prims.int ->     from_col: Prims.int ->     to_line: Prims.int ->     to_col: Prims.int   -> Prims.range
(declare-fun Tm_arrow_5f96b500c0940697aac1b5a6625b2368 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5f96b500c0940697aac1b5a6625b2368
;;; Fact-ids: Name Prims.mk_range; Namespace Prims
(assert (! (HasType Tm_arrow_5f96b500c0940697aac1b5a6625b2368
Tm_type)
:named kinding_Tm_arrow_5f96b500c0940697aac1b5a6625b2368))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.mk_range; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5f96b500c0940697aac1b5a6625b2368)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5f96b500c0940697aac1b5a6625b2368))
:qid Prims_pre_typing_Tm_arrow_5f96b500c0940697aac1b5a6625b2368))

:named Prims_pre_typing_Tm_arrow_5f96b500c0940697aac1b5a6625b2368))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368
;;; Fact-ids: Name Prims.mk_range; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5f96b500c0940697aac1b5a6625b2368)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Prims.string)
(HasType @x2
Prims.int)
(HasType @x3
Prims.int)
(HasType @x4
Prims.int)
(HasType @x5
Prims.int))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Prims.range))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.string)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Prims.string)
(HasType @x2
Prims.int))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Prims.string)
(HasType @x2
Prims.int)
(HasType @x3
Prims.int))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,75-509,80)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Prims.string)
(HasType @x2
Prims.int)
(HasType @x3
Prims.int)
(HasType @x4
Prims.int))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5f96b500c0940697aac1b5a6625b2368))
:qid Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368))

:named Prims_interpretation_Tm_arrow_5f96b500c0940697aac1b5a6625b2368))
(declare-fun Prims.mk_range@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.mk_range; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.mk_range@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(Prims.mk_range @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.mk_range@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_Prims.mk_range))

:named token_correspondence_Prims.mk_range))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.mk_range; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.mk_range@tok
Tm_arrow_5f96b500c0940697aac1b5a6625b2368))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.mk_range@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(Prims.mk_range @x1
@x2
@x3
@x4
@x5))
 

:pattern ((Prims.mk_range @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_Prims.mk_range.1))
)
 

:pattern ((ApplyTT @x0
Prims.mk_range@tok))
:qid function_token_typing_Prims.mk_range))

:named function_token_typing_Prims.mk_range))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.mk_range; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(509,4-509,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Prims.string)
(HasType @x1
Prims.int)
(HasType @x2
Prims.int)
(HasType @x3
Prims.int)
(HasType @x4
Prims.int))
(HasType (Prims.mk_range @x0
@x1
@x2
@x3
@x4)
Prims.range))
 

:pattern ((Prims.mk_range @x0
@x1
@x2
@x3
@x4))
:qid typing_Prims.mk_range))

:named typing_Prims.mk_range))

; </end encoding Prims.mk_range>


; <Start encoding Prims.op_AmpAmp>

(declare-fun Prims.op_AmpAmp (Term Term) Term)
(declare-fun Prims.op_AmpAmp@tok () Term)
;;; Fact-ids: Name Prims.op_AmpAmp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(517,4-517,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(517,4-517,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.op_AmpAmp @x0
@x1)
(BoxBool (and (BoxBool_proj_0 @x0)
(BoxBool_proj_0 @x1))))
 

:pattern ((Prims.op_AmpAmp @x0
@x1))
:qid primitive_Prims.op_AmpAmp))

:named primitive_Prims.op_AmpAmp))
;;; Fact-ids: Name Prims.op_AmpAmp; Namespace Prims
(assert (! (IsTotFun Prims.op_AmpAmp@tok)
:named primitive_tot_fun_Prims.op_AmpAmp))
;;; Fact-ids: Name Prims.op_AmpAmp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(517,4-517,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(517,4-517,13)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_AmpAmp@tok
@x0))
 

:pattern ((ApplyTT Prims.op_AmpAmp@tok
@x0))
:qid primitive_tot_fun_Prims.op_AmpAmp.1))

:named primitive_tot_fun_Prims.op_AmpAmp.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_AmpAmp; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(517,4-517,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(517,4-517,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_AmpAmp@tok
@x0)
@x1)
(Prims.op_AmpAmp @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_AmpAmp@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_AmpAmp))

:named token_correspondence_Prims.op_AmpAmp))

; </end encoding Prims.op_AmpAmp>


; <Start encoding Prims.op_BarBar>

(declare-fun Prims.op_BarBar (Term Term) Term)
(declare-fun Prims.op_BarBar@tok () Term)
;;; Fact-ids: Name Prims.op_BarBar; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(523,4-523,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(523,4-523,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))
;;; Fact-ids: Name Prims.op_BarBar; Namespace Prims
(assert (! (IsTotFun Prims.op_BarBar@tok)
:named primitive_tot_fun_Prims.op_BarBar))
;;; Fact-ids: Name Prims.op_BarBar; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(523,4-523,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(523,4-523,13)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_BarBar@tok
@x0))
 

:pattern ((ApplyTT Prims.op_BarBar@tok
@x0))
:qid primitive_tot_fun_Prims.op_BarBar.1))

:named primitive_tot_fun_Prims.op_BarBar.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_BarBar; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(523,4-523,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(523,4-523,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_BarBar@tok
@x0)
@x1)
(Prims.op_BarBar @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_BarBar@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_BarBar))

:named token_correspondence_Prims.op_BarBar))

; </end encoding Prims.op_BarBar>


; <Start encoding Prims.op_Negation>

(declare-fun Prims.op_Negation (Term) Term)
(declare-fun Prims.op_Negation@tok () Term)
;;; Fact-ids: Name Prims.op_Negation; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(529,4-529,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(529,4-529,15)
(forall ((@x0 Term))
 (! (= (Prims.op_Negation @x0)
(BoxBool (not (BoxBool_proj_0 @x0))))
 

:pattern ((Prims.op_Negation @x0))
:qid primitive_Prims.op_Negation))

:named primitive_Prims.op_Negation))
;;; Fact-ids: Name Prims.op_Negation; Namespace Prims
(assert (! (IsTotFun Prims.op_Negation@tok)
:named primitive_tot_fun_Prims.op_Negation))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Negation; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(529,4-529,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(529,4-529,15)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.op_Negation@tok
@x0)
(Prims.op_Negation @x0))
 

:pattern ((ApplyTT Prims.op_Negation@tok
@x0))
:qid token_correspondence_Prims.op_Negation))

:named token_correspondence_Prims.op_Negation))

; </end encoding Prims.op_Negation>


; <Start encoding Prims.op_Multiply>

(declare-fun Prims.op_Multiply (Term Term) Term)
(declare-fun Prims.op_Multiply@tok () Term)
;;; Fact-ids: Name Prims.op_Multiply; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(535,4-535,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(535,4-535,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_Multiply; Namespace Prims
(assert (! (IsTotFun Prims.op_Multiply@tok)
:named primitive_tot_fun_Prims.op_Multiply))
;;; Fact-ids: Name Prims.op_Multiply; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(535,4-535,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(535,4-535,15)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_Multiply@tok
@x0))
 

:pattern ((ApplyTT Prims.op_Multiply@tok
@x0))
:qid primitive_tot_fun_Prims.op_Multiply.1))

:named primitive_tot_fun_Prims.op_Multiply.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Multiply; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(535,4-535,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(535,4-535,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_Multiply@tok
@x0)
@x1)
(Prims.op_Multiply @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_Multiply@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_Multiply))

:named token_correspondence_Prims.op_Multiply))

; </end encoding Prims.op_Multiply>


; <Start encoding Prims.op_Subtraction>

(declare-fun Prims.op_Subtraction (Term Term) Term)
(declare-fun Prims.op_Subtraction@tok () Term)
;;; Fact-ids: Name Prims.op_Subtraction; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(541,4-541,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(541,4-541,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_Subtraction; Namespace Prims
(assert (! (IsTotFun Prims.op_Subtraction@tok)
:named primitive_tot_fun_Prims.op_Subtraction))
;;; Fact-ids: Name Prims.op_Subtraction; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(541,4-541,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(541,4-541,18)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_Subtraction@tok
@x0))
 

:pattern ((ApplyTT Prims.op_Subtraction@tok
@x0))
:qid primitive_tot_fun_Prims.op_Subtraction.1))

:named primitive_tot_fun_Prims.op_Subtraction.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Subtraction; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(541,4-541,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(541,4-541,18)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_Subtraction@tok
@x0)
@x1)
(Prims.op_Subtraction @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_Subtraction@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_Subtraction))

:named token_correspondence_Prims.op_Subtraction))

; </end encoding Prims.op_Subtraction>


; <Start encoding Prims.op_Addition>

(declare-fun Prims.op_Addition (Term Term) Term)
(declare-fun Prims.op_Addition@tok () Term)
;;; Fact-ids: Name Prims.op_Addition; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(547,4-547,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(547,4-547,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))
;;; Fact-ids: Name Prims.op_Addition; Namespace Prims
(assert (! (IsTotFun Prims.op_Addition@tok)
:named primitive_tot_fun_Prims.op_Addition))
;;; Fact-ids: Name Prims.op_Addition; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(547,4-547,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(547,4-547,15)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_Addition@tok
@x0))
 

:pattern ((ApplyTT Prims.op_Addition@tok
@x0))
:qid primitive_tot_fun_Prims.op_Addition.1))

:named primitive_tot_fun_Prims.op_Addition.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Addition; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(547,4-547,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(547,4-547,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_Addition@tok
@x0)
@x1)
(Prims.op_Addition @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_Addition@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_Addition))

:named token_correspondence_Prims.op_Addition))

; </end encoding Prims.op_Addition>


; <Start encoding Prims.op_Minus>

(declare-fun Prims.op_Minus (Term) Term)
(declare-fun Prims.op_Minus@tok () Term)
;;; Fact-ids: Name Prims.op_Minus; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(553,4-553,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(553,4-553,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))
;;; Fact-ids: Name Prims.op_Minus; Namespace Prims
(assert (! (IsTotFun Prims.op_Minus@tok)
:named primitive_tot_fun_Prims.op_Minus))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Minus; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(553,4-553,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(553,4-553,12)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.op_Minus@tok
@x0)
(Prims.op_Minus @x0))
 

:pattern ((ApplyTT Prims.op_Minus@tok
@x0))
:qid token_correspondence_Prims.op_Minus))

:named token_correspondence_Prims.op_Minus))

; </end encoding Prims.op_Minus>


; <Start encoding Prims.op_LessThanOrEqual>

(declare-fun Prims.op_LessThanOrEqual (Term Term) Term)
(declare-fun Prims.op_LessThanOrEqual@tok () Term)
;;; Fact-ids: Name Prims.op_LessThanOrEqual; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,4-559,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,4-559,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_LessThanOrEqual; Namespace Prims
(assert (! (IsTotFun Prims.op_LessThanOrEqual@tok)
:named primitive_tot_fun_Prims.op_LessThanOrEqual))
;;; Fact-ids: Name Prims.op_LessThanOrEqual; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,4-559,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,4-559,22)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_LessThanOrEqual@tok
@x0))
 

:pattern ((ApplyTT Prims.op_LessThanOrEqual@tok
@x0))
:qid primitive_tot_fun_Prims.op_LessThanOrEqual.1))

:named primitive_tot_fun_Prims.op_LessThanOrEqual.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_LessThanOrEqual; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,4-559,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,4-559,22)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_LessThanOrEqual@tok
@x0)
@x1)
(Prims.op_LessThanOrEqual @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_LessThanOrEqual@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_LessThanOrEqual))

:named token_correspondence_Prims.op_LessThanOrEqual))

; </end encoding Prims.op_LessThanOrEqual>


; <Start encoding Prims.op_GreaterThan>

(declare-fun Prims.op_GreaterThan (Term Term) Term)
(declare-fun Prims.op_GreaterThan@tok () Term)
;;; Fact-ids: Name Prims.op_GreaterThan; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(565,4-565,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(565,4-565,18)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.op_GreaterThan @x0
@x1)
(BoxBool (> (BoxInt_proj_0 @x0)
(BoxInt_proj_0 @x1))))
 

:pattern ((Prims.op_GreaterThan @x0
@x1))
:qid primitive_Prims.op_GreaterThan))

:named primitive_Prims.op_GreaterThan))
;;; Fact-ids: Name Prims.op_GreaterThan; Namespace Prims
(assert (! (IsTotFun Prims.op_GreaterThan@tok)
:named primitive_tot_fun_Prims.op_GreaterThan))
;;; Fact-ids: Name Prims.op_GreaterThan; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(565,4-565,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(565,4-565,18)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_GreaterThan@tok
@x0))
 

:pattern ((ApplyTT Prims.op_GreaterThan@tok
@x0))
:qid primitive_tot_fun_Prims.op_GreaterThan.1))

:named primitive_tot_fun_Prims.op_GreaterThan.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_GreaterThan; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(565,4-565,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(565,4-565,18)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_GreaterThan@tok
@x0)
@x1)
(Prims.op_GreaterThan @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_GreaterThan@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_GreaterThan))

:named token_correspondence_Prims.op_GreaterThan))

; </end encoding Prims.op_GreaterThan>


; <Start encoding Prims.op_GreaterThanOrEqual>

(declare-fun Prims.op_GreaterThanOrEqual (Term Term) Term)
(declare-fun Prims.op_GreaterThanOrEqual@tok () Term)
;;; Fact-ids: Name Prims.op_GreaterThanOrEqual; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(571,4-571,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(571,4-571,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))
;;; Fact-ids: Name Prims.op_GreaterThanOrEqual; Namespace Prims
(assert (! (IsTotFun Prims.op_GreaterThanOrEqual@tok)
:named primitive_tot_fun_Prims.op_GreaterThanOrEqual))
;;; Fact-ids: Name Prims.op_GreaterThanOrEqual; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(571,4-571,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(571,4-571,25)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_GreaterThanOrEqual@tok
@x0))
 

:pattern ((ApplyTT Prims.op_GreaterThanOrEqual@tok
@x0))
:qid primitive_tot_fun_Prims.op_GreaterThanOrEqual.1))

:named primitive_tot_fun_Prims.op_GreaterThanOrEqual.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_GreaterThanOrEqual; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(571,4-571,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(571,4-571,25)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_GreaterThanOrEqual@tok
@x0)
@x1)
(Prims.op_GreaterThanOrEqual @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_GreaterThanOrEqual@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_GreaterThanOrEqual))

:named token_correspondence_Prims.op_GreaterThanOrEqual))

; </end encoding Prims.op_GreaterThanOrEqual>


; <Start encoding Prims.op_LessThan>

(declare-fun Prims.op_LessThan (Term Term) Term)
(declare-fun Prims.op_LessThan@tok () Term)
;;; Fact-ids: Name Prims.op_LessThan; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(577,4-577,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(577,4-577,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))
;;; Fact-ids: Name Prims.op_LessThan; Namespace Prims
(assert (! (IsTotFun Prims.op_LessThan@tok)
:named primitive_tot_fun_Prims.op_LessThan))
;;; Fact-ids: Name Prims.op_LessThan; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(577,4-577,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(577,4-577,15)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_LessThan@tok
@x0))
 

:pattern ((ApplyTT Prims.op_LessThan@tok
@x0))
:qid primitive_tot_fun_Prims.op_LessThan.1))

:named primitive_tot_fun_Prims.op_LessThan.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_LessThan; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(577,4-577,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(577,4-577,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_LessThan@tok
@x0)
@x1)
(Prims.op_LessThan @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_LessThan@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_LessThan))

:named token_correspondence_Prims.op_LessThan))

; </end encoding Prims.op_LessThan>


; <Start encoding Prims.op_Equality>

(declare-fun Prims.op_Equality (Term Term Term) Term)
(declare-fun Prims.op_Equality@tok () Term)
;;; Fact-ids: Name Prims.op_Equality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,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_Equality; Namespace Prims
(assert (! (IsTotFun Prims.op_Equality@tok)
:named primitive_tot_fun_Prims.op_Equality))
;;; Fact-ids: Name Prims.op_Equality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_Equality@tok
@x0))
 

:pattern ((ApplyTT Prims.op_Equality@tok
@x0))
:qid primitive_tot_fun_Prims.op_Equality.1))

:named primitive_tot_fun_Prims.op_Equality.1))
;;; Fact-ids: Name Prims.op_Equality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT Prims.op_Equality@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_Equality@tok
@x0)
@x1))
:qid primitive_tot_fun_Prims.op_Equality.2))

:named primitive_tot_fun_Prims.op_Equality.2))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Equality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(583,4-583,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.op_Equality@tok
@x0)
@x1)
@x2)
(Prims.op_Equality @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.op_Equality@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.op_Equality))

:named token_correspondence_Prims.op_Equality))

; </end encoding Prims.op_Equality>


; <Start encoding Prims.op_disEquality>

(declare-fun Prims.op_disEquality (Term Term Term) Term)
(declare-fun Prims.op_disEquality@tok () Term)
;;; Fact-ids: Name Prims.op_disEquality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Prims.op_disEquality @x0
@x1
@x2)
(BoxBool (not (= @x1
@x2))))
 

:pattern ((Prims.op_disEquality @x0
@x1
@x2))
:qid primitive_Prims.op_disEquality))

:named primitive_Prims.op_disEquality))
;;; Fact-ids: Name Prims.op_disEquality; Namespace Prims
(assert (! (IsTotFun Prims.op_disEquality@tok)
:named primitive_tot_fun_Prims.op_disEquality))
;;; Fact-ids: Name Prims.op_disEquality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_disEquality@tok
@x0))
 

:pattern ((ApplyTT Prims.op_disEquality@tok
@x0))
:qid primitive_tot_fun_Prims.op_disEquality.1))

:named primitive_tot_fun_Prims.op_disEquality.1))
;;; Fact-ids: Name Prims.op_disEquality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT Prims.op_disEquality@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_disEquality@tok
@x0)
@x1))
:qid primitive_tot_fun_Prims.op_disEquality.2))

:named primitive_tot_fun_Prims.op_disEquality.2))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_disEquality; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(589,4-589,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.op_disEquality@tok
@x0)
@x1)
@x2)
(Prims.op_disEquality @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.op_disEquality@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.op_disEquality))

:named token_correspondence_Prims.op_disEquality))

; </end encoding Prims.op_disEquality>


; <Start encoding Prims.exn>

(declare-fun Prims.exn () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.exn; Namespace Prims
(assert (! (HasType Prims.exn
Tm_type)
:named function_token_typing_Prims.exn))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.exn; Namespace Prims
(assert (! (= 321
(Term_constr_id Prims.exn))
:named constructor_distinct_Prims.exn))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.exn; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(593,5-593,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(593,5-593,8)
(forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.exn)
(= Prims.exn
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
Prims.exn))
:qid Prims_pretyping_2feddfe489e78a01f5d2e9b55172b46a))

:named Prims_pretyping_2feddfe489e78a01f5d2e9b55172b46a))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.exn; Namespace Prims
(assert (! (HasType Prims.exn
Tm_type)
:named typing_Prims.exn))

; </end encoding Prims.exn>


; <Start encoding Prims.array>

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

(declare-fun Prims.array@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.array; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.array@tok
@x0)
(Prims.array @x0))
 

:pattern ((ApplyTT Prims.array@tok
@x0))
:qid token_correspondence_Prims.array))

:named token_correspondence_Prims.array))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.array; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.array@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.array@tok
@x1)
(Prims.array @x1))
 

:pattern ((Prims.array @x1))
:qid function_token_typing_Prims.array.1))
)
 

:pattern ((ApplyTT @x0
Prims.array@tok))
:qid function_token_typing_Prims.array))

:named function_token_typing_Prims.array))
;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.array; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10)
(forall ((@x0 Term))
 (! (= 326
(Term_constr_id (Prims.array @x0)))
 

:pattern ((Prims.array @x0))
:qid constructor_distinct_Prims.array))

:named constructor_distinct_Prims.array))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.array; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.array @x2))
(= (Prims.array @x2)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(Prims.array @x2)))
:qid Prims_pretyping_4ad2a9f57b811db36dfacf4f739b0d18))

:named Prims_pretyping_4ad2a9f57b811db36dfacf4f739b0d18))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.array; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(598,5-598,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.array @x0)
Tm_type))
 

:pattern ((Prims.array @x0))
:qid typing_Prims.array))

:named typing_Prims.array))

; </end encoding Prims.array>


; <Start encoding Prims.strcat>

(declare-fun Prims.strcat (Term Term) Term)
;;;;;;;;;;;;;;;;_: Prims.string -> _: Prims.string -> Prims.string
(declare-fun Tm_arrow_b66cecec1d56111347abe61e89557dd1 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b66cecec1d56111347abe61e89557dd1
;;; Fact-ids: Name Prims.strcat; Namespace Prims
(assert (! (HasType Tm_arrow_b66cecec1d56111347abe61e89557dd1
Tm_type)
:named kinding_Tm_arrow_b66cecec1d56111347abe61e89557dd1))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.strcat; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_b66cecec1d56111347abe61e89557dd1)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_b66cecec1d56111347abe61e89557dd1))
:qid Prims_pre_typing_Tm_arrow_b66cecec1d56111347abe61e89557dd1))

:named Prims_pre_typing_Tm_arrow_b66cecec1d56111347abe61e89557dd1))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b66cecec1d56111347abe61e89557dd1
;;; Fact-ids: Name Prims.strcat; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_b66cecec1d56111347abe61e89557dd1)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Prims.string)
(HasType @x2
Prims.string))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.string))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_b66cecec1d56111347abe61e89557dd1.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,36-604,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.string)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_b66cecec1d56111347abe61e89557dd1.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_b66cecec1d56111347abe61e89557dd1))
:qid Prims_interpretation_Tm_arrow_b66cecec1d56111347abe61e89557dd1))

:named Prims_interpretation_Tm_arrow_b66cecec1d56111347abe61e89557dd1))
(declare-fun Prims.strcat@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.strcat; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.strcat@tok
@x0)
@x1)
(Prims.strcat @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.strcat@tok
@x0)
@x1))
:qid token_correspondence_Prims.strcat))

:named token_correspondence_Prims.strcat))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.strcat; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.strcat@tok
Tm_arrow_b66cecec1d56111347abe61e89557dd1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.strcat@tok
@x1)
@x2)
(Prims.strcat @x1
@x2))
 

:pattern ((Prims.strcat @x1
@x2))
:qid function_token_typing_Prims.strcat.1))
)
 

:pattern ((ApplyTT @x0
Prims.strcat@tok))
:qid function_token_typing_Prims.strcat))

:named function_token_typing_Prims.strcat))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.strcat; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(604,4-604,10)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.string)
(HasType @x1
Prims.string))
(HasType (Prims.strcat @x0
@x1)
Prims.string))
 

:pattern ((Prims.strcat @x0
@x1))
:qid typing_Prims.strcat))

:named typing_Prims.strcat))

; </end encoding Prims.strcat>


; <Skipped Prims.op_Hat/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.list (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.list@x0 (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: 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: Cons
(declare-fun Prims.Cons@tok () Term)
;;;;;;;;;;;;;;;;Prims.list a
(declare-fun Tm_arrow_3864bd5fbb999b4fe4487408df9b3401 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! (HasType Tm_arrow_3864bd5fbb999b4fe4487408df9b3401
Tm_type)
:named kinding_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,10-610,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,10-610,16)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3864bd5fbb999b4fe4487408df9b3401)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))
:qid Prims_pre_typing_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))

:named Prims_pre_typing_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,10-610,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,10-610,16)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3864bd5fbb999b4fe4487408df9b3401)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,10-610,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,10-610,16)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
(Prims.list @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))
:qid Prims_interpretation_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))

:named Prims_interpretation_Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))
;;;;;;;;;;;;;;;;hd: a -> tl: Prims.list a -> Prims.list a
(declare-fun Tm_arrow_02c072760cbad0f5a4706f6cffab6c94 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! (HasType Tm_arrow_02c072760cbad0f5a4706f6cffab6c94
Tm_type)
:named kinding_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_02c072760cbad0f5a4706f6cffab6c94)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))
:qid Prims_pre_typing_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))

:named Prims_pre_typing_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_02c072760cbad0f5a4706f6cffab6c94)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
(Prims.list @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Prims.list @x1)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,34-611,40)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))
:qid Prims_interpretation_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))

:named Prims_interpretation_Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))

; <Start encoding Prims.list>


; <start constructor Prims.list>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,9)
(forall ((@x0 Term))
 (! (= 331
(Term_constr_id (Prims.list @x0)))
 

:pattern ((Prims.list @x0))
:qid constructor_distinct_Prims.list))

:named constructor_distinct_Prims.list))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.list ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
331)
(exists ((@x0 Term))
 (! (= __@x0
(Prims.list @x0))
 
;;no pats
:qid is-Prims.list))))

; </end constructor Prims.list>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! (= 332
(Term_constr_id Prims.list@tok))
:named fresh_token_Prims.list@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,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))
;;;;;;;;;;;;;;;;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))
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! (and (IsTotFun Prims.list@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,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))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,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))

; </end encoding Prims.list>


; <Start encoding Prims.Nil>


; <start constructor Prims.Nil>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term))
 (! (= 338
(Term_constr_id (Prims.Nil @x0)))
 

:pattern ((Prims.Nil @x0))
:qid constructor_distinct_Prims.Nil))

:named constructor_distinct_Prims.Nil))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,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))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Nil ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
338)
(= __@x0
(Prims.Nil (Prims.Nil_a __@x0)))))

; </end constructor Prims.Nil>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! (= 341
(Term_constr_id Prims.Nil@tok))
:named fresh_token_Prims.Nil@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Nil@tok
Tm_arrow_3864bd5fbb999b4fe4487408df9b3401))
 

:pattern ((ApplyTT Prims.Nil@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Nil@tok))
:qid typing_tok_Prims.Nil@tok))

:named typing_tok_Prims.Nil@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.Nil@tok
@x0)
(Prims.Nil @x0))
 

:pattern ((ApplyTT Prims.Nil@tok
@x0))
:qid equality_tok_Prims.Nil@tok))

:named equality_tok_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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,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 elim
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Nil @x1)
(Prims.list @x2))
(and (HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x1
Tm_type)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Nil @x1)
(Prims.list @x2)))
:qid data_elim_Prims.Nil))

:named data_elim_Prims.Nil))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! true
:named subterm_ordering_Prims.Nil))

; </end encoding Prims.Nil>


; <Start encoding Prims.Cons>


; <start constructor Prims.Cons>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 343
(Term_constr_id (Prims.Cons @x0
@x1
@x2)))
 

:pattern ((Prims.Cons @x0
@x1
@x2))
:qid constructor_distinct_Prims.Cons))

:named constructor_distinct_Prims.Cons))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,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))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,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))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Cons ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
343)
(= __@x0
(Prims.Cons (Prims.Cons_a __@x0)
(Prims.Cons_hd __@x0)
(Prims.Cons_tl __@x0)))))

; </end constructor Prims.Cons>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! (= 346
(Term_constr_id Prims.Cons@tok))
:named fresh_token_Prims.Cons@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType Prims.Cons@tok
Tm_arrow_02c072760cbad0f5a4706f6cffab6c94))
 

:pattern ((ApplyTT Prims.Cons@tok
@x0))

:pattern ((ApplyTT @x0
Prims.Cons@tok))
:qid typing_tok_Prims.Cons@tok))

:named typing_tok_Prims.Cons@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.Cons@tok
@x0)
@x1)
@x2)
(Prims.Cons @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.Cons@tok
@x0)
@x1)
@x2))
:qid equality_tok_Prims.Cons@tok))

:named equality_tok_Prims.Cons@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,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))
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
@x1)
(HasTypeFuel @u0
@x3
(Prims.list @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Cons @x1
@x2
@x3)
(Prims.list @x4)))
:qid data_elim_Prims.Cons))

:named data_elim_Prims.Cons))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,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))

; </end encoding Prims.Cons>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name Prims.list; Namespace Prims; Name Prims.Nil; Namespace Prims; Name Prims.Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,5-609,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))

; </end encoding >


; <Start encoding Prims.list__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: 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))

; </end encoding Prims.list__uu___haseq>


; <Start encoding Prims.uu___is_Nil>

(declare-fun Prims.uu___is_Nil (Term Term) Term)
;;;;;;;;;;;;;;;;projectee: Prims.list a -> Prims.bool
(declare-fun Tm_arrow_606904b0fa72729a20285beb231f9f2e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_606904b0fa72729a20285beb231f9f2e
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! (HasType Tm_arrow_606904b0fa72729a20285beb231f9f2e
Tm_type)
:named kinding_Tm_arrow_606904b0fa72729a20285beb231f9f2e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_606904b0fa72729a20285beb231f9f2e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_606904b0fa72729a20285beb231f9f2e))
:qid Prims_pre_typing_Tm_arrow_606904b0fa72729a20285beb231f9f2e))
:named Prims_pre_typing_Tm_arrow_606904b0fa72729a20285beb231f9f2e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_606904b0fa72729a20285beb231f9f2e
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_606904b0fa72729a20285beb231f9f2e)
(and (forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Prims.list @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_606904b0fa72729a20285beb231f9f2e.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_606904b0fa72729a20285beb231f9f2e.2))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_606904b0fa72729a20285beb231f9f2e))
:qid Prims_interpretation_Tm_arrow_606904b0fa72729a20285beb231f9f2e))
:named Prims_interpretation_Tm_arrow_606904b0fa72729a20285beb231f9f2e))
(declare-fun Prims.uu___is_Nil@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.uu___is_Nil@tok
@x0)
@x1)
(Prims.uu___is_Nil @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.uu___is_Nil@tok
@x0)
@x1))
:qid token_correspondence_Prims.uu___is_Nil))

:named token_correspondence_Prims.uu___is_Nil))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Nil@tok
Tm_arrow_606904b0fa72729a20285beb231f9f2e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.uu___is_Nil@tok
@x1)
@x2)
(Prims.uu___is_Nil @x1
@x2))
 

:pattern ((Prims.uu___is_Nil @x1
@x2))
:qid function_token_typing_Prims.uu___is_Nil.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Nil@tok))
:qid function_token_typing_Prims.uu___is_Nil))

:named function_token_typing_Prims.uu___is_Nil))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Prims.list @x0)))
(HasType (Prims.uu___is_Nil @x0
@x1)
Prims.bool))
 

:pattern ((Prims.uu___is_Nil @x0
@x1))
:qid typing_Prims.uu___is_Nil))

:named typing_Prims.uu___is_Nil))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Nil; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(610,4-610,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.uu___is_Nil @x0
@x1)
(BoxBool (is-Prims.Nil @x1)))
 

:pattern ((Prims.uu___is_Nil @x0
@x1))
:qid disc_equation_Prims.Nil))

:named disc_equation_Prims.Nil))

; </end encoding Prims.uu___is_Nil>


; <Skipped Prims.uu___is_Nil/>


; <Start encoding Prims.uu___is_Cons>

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

(declare-fun Prims.uu___is_Cons@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.uu___is_Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.uu___is_Cons@tok
@x0)
@x1)
(Prims.uu___is_Cons @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.uu___is_Cons@tok
@x0)
@x1))
:qid token_correspondence_Prims.uu___is_Cons))

:named token_correspondence_Prims.uu___is_Cons))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.uu___is_Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.uu___is_Cons@tok
Tm_arrow_606904b0fa72729a20285beb231f9f2e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.uu___is_Cons@tok
@x1)
@x2)
(Prims.uu___is_Cons @x1
@x2))
 

:pattern ((Prims.uu___is_Cons @x1
@x2))
:qid function_token_typing_Prims.uu___is_Cons.1))
)
 

:pattern ((ApplyTT @x0
Prims.uu___is_Cons@tok))
:qid function_token_typing_Prims.uu___is_Cons))

:named function_token_typing_Prims.uu___is_Cons))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.uu___is_Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Prims.list @x0)))
(HasType (Prims.uu___is_Cons @x0
@x1)
Prims.bool))
 

:pattern ((Prims.uu___is_Cons @x0
@x1))
:qid typing_Prims.uu___is_Cons))

:named typing_Prims.uu___is_Cons))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name Prims.uu___is_Cons; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.uu___is_Cons @x0
@x1)
(BoxBool (is-Prims.Cons @x1)))
 

:pattern ((Prims.uu___is_Cons @x0
@x1))
:qid disc_equation_Prims.Cons))

:named disc_equation_Prims.Cons))

; </end encoding Prims.uu___is_Cons>


; <Skipped Prims.uu___is_Cons/>


; <Start encoding Prims.__proj__Cons__item__hd>

(declare-fun Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32))

:named refinement_kinding_Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x2))
(and (HasTypeFuel @u0
@x1
(Prims.list @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(BoxBool_proj_0 (Prims.uu___is_Cons @x2
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x2)))
:qid refinement_interpretation_Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32))

:named refinement_interpretation_Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32))
;;;;;;;;;;;;;;;;haseq for Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,4-611,8)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x0)))
(Valid (Prims.hasEq (Prims.list @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x0))))
:qid haseqTm_refine_7aac12c24449a22c34d98a0ea8ed4a32))

:named haseqTm_refine_7aac12c24449a22c34d98a0ea8ed4a32))
(declare-fun Prims.__proj__Cons__item__hd (Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: Prims.list a {Cons? _} -> a
(declare-fun Tm_arrow_27c3547831737e5a63950f3d18bf3d22 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_27c3547831737e5a63950f3d18bf3d22
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! (HasType Tm_arrow_27c3547831737e5a63950f3d18bf3d22
Tm_type)
:named kinding_Tm_arrow_27c3547831737e5a63950f3d18bf3d22))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_27c3547831737e5a63950f3d18bf3d22)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_27c3547831737e5a63950f3d18bf3d22))
:qid Prims_pre_typing_Tm_arrow_27c3547831737e5a63950f3d18bf3d22))

:named Prims_pre_typing_Tm_arrow_27c3547831737e5a63950f3d18bf3d22))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_27c3547831737e5a63950f3d18bf3d22
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_27c3547831737e5a63950f3d18bf3d22)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x1))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_27c3547831737e5a63950f3d18bf3d22.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(609,11-609,12)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_27c3547831737e5a63950f3d18bf3d22.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_27c3547831737e5a63950f3d18bf3d22))
:qid Prims_interpretation_Tm_arrow_27c3547831737e5a63950f3d18bf3d22))

:named Prims_interpretation_Tm_arrow_27c3547831737e5a63950f3d18bf3d22))
(declare-fun Prims.__proj__Cons__item__hd@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.__proj__Cons__item__hd@tok
@x0)
@x1)
(Prims.__proj__Cons__item__hd @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.__proj__Cons__item__hd@tok
@x0)
@x1))
:qid token_correspondence_Prims.__proj__Cons__item__hd))

:named token_correspondence_Prims.__proj__Cons__item__hd))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Cons__item__hd@tok
Tm_arrow_27c3547831737e5a63950f3d18bf3d22))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.__proj__Cons__item__hd@tok
@x1)
@x2)
(Prims.__proj__Cons__item__hd @x1
@x2))
 

:pattern ((Prims.__proj__Cons__item__hd @x1
@x2))
:qid function_token_typing_Prims.__proj__Cons__item__hd.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Cons__item__hd@tok))
:qid function_token_typing_Prims.__proj__Cons__item__hd))

:named function_token_typing_Prims.__proj__Cons__item__hd))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x0)))
(HasType (Prims.__proj__Cons__item__hd @x0
@x1)
@x0))
 

:pattern ((Prims.__proj__Cons__item__hd @x0
@x1))
:qid typing_Prims.__proj__Cons__item__hd))

:named typing_Prims.__proj__Cons__item__hd))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Cons__item__hd; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,11-611,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.__proj__Cons__item__hd @x0
@x1)
(Prims.Cons_hd @x1))
 

:pattern ((Prims.__proj__Cons__item__hd @x0
@x1))
:qid proj_equation_Prims.Cons_hd))

:named proj_equation_Prims.Cons_hd))

; </end encoding Prims.__proj__Cons__item__hd>


; <Skipped Prims.__proj__Cons__item__hd/>


; <Start encoding Prims.__proj__Cons__item__tl>


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

;;;;;;;;;;;;;;;;projectee: _: Prims.list a {Cons? _} -> Prims.list a
(declare-fun Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! (HasType Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21
Tm_type)
:named kinding_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))
:qid Prims_pre_typing_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))

:named Prims_pre_typing_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(Prims.list @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,24-611,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))
:qid Prims_interpretation_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))

:named Prims_interpretation_Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))
(declare-fun Prims.__proj__Cons__item__tl@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.__proj__Cons__item__tl@tok
@x0)
@x1)
(Prims.__proj__Cons__item__tl @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.__proj__Cons__item__tl@tok
@x0)
@x1))
:qid token_correspondence_Prims.__proj__Cons__item__tl))

:named token_correspondence_Prims.__proj__Cons__item__tl))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.__proj__Cons__item__tl@tok
Tm_arrow_4e740085106d54d8b48ffe3c6c20ef21))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.__proj__Cons__item__tl@tok
@x1)
@x2)
(Prims.__proj__Cons__item__tl @x1
@x2))
 

:pattern ((Prims.__proj__Cons__item__tl @x1
@x2))
:qid function_token_typing_Prims.__proj__Cons__item__tl.1))
)
 

:pattern ((ApplyTT @x0
Prims.__proj__Cons__item__tl@tok))
:qid function_token_typing_Prims.__proj__Cons__item__tl))

:named function_token_typing_Prims.__proj__Cons__item__tl))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_refine_7aac12c24449a22c34d98a0ea8ed4a32 @x0)))
(HasType (Prims.__proj__Cons__item__tl @x0
@x1)
(Prims.list @x0)))
 

:pattern ((Prims.__proj__Cons__item__tl @x0
@x1))
:qid typing_Prims.__proj__Cons__item__tl))

:named typing_Prims.__proj__Cons__item__tl))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name Prims.__proj__Cons__item__tl; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(611,20-611,22)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.__proj__Cons__item__tl @x0
@x1)
(Prims.Cons_tl @x1))
 

:pattern ((Prims.__proj__Cons__item__tl @x0
@x1))
:qid proj_equation_Prims.Cons_tl))

:named proj_equation_Prims.Cons_tl))

; </end encoding Prims.__proj__Cons__item__tl>


; <Skipped Prims.__proj__Cons__item__tl/>


; <Skipped Prims.M/>


; <Start encoding Prims.returnM>

(declare-fun Prims.returnM (Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> x: a -> Prims.M a
(declare-fun Tm_arrow_99724436653747ac6f5a6a00c64ff8bc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! (HasType Tm_arrow_99724436653747ac6f5a6a00c64ff8bc
Tm_type)
:named kinding_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,13-620,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,33-620,34)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))
:qid Prims_pre_typing_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))

:named Prims_pre_typing_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,13-620,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,33-620,34)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,13-620,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,33-620,34)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x1))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,13-620,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,33-620,34)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))
:qid Prims_interpretation_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))

:named Prims_interpretation_Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))
(declare-fun Prims.returnM@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.returnM@tok
@x0)
@x1)
(Prims.returnM @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.returnM@tok
@x0)
@x1))
:qid token_correspondence_Prims.returnM))

:named token_correspondence_Prims.returnM))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.returnM@tok
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.returnM@tok
@x1)
@x2)
(Prims.returnM @x1
@x2))
 

:pattern ((Prims.returnM @x1
@x2))
:qid function_token_typing_Prims.returnM.1))
)
 

:pattern ((ApplyTT @x0
Prims.returnM@tok))
:qid function_token_typing_Prims.returnM))

:named function_token_typing_Prims.returnM))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (Prims.returnM @x0
@x1)
@x0))
 

:pattern ((Prims.returnM @x0
@x1))
:qid typing_Prims.returnM))

:named typing_Prims.returnM))
;;;;;;;;;;;;;;;;Equation for Prims.returnM
;;; Fact-ids: Name Prims.returnM; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(620,4-620,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.returnM @x0
@x1)
@x1)
 

:pattern ((Prims.returnM @x0
@x1))
:qid equation_Prims.returnM))

:named equation_Prims.returnM))

; </end encoding Prims.returnM>


; <Skipped Prims.as_requires/>


; <Skipped Prims.as_ensures/>


; <Start encoding Prims._assume>

(declare-fun Prims._assume (Term) Term)
(declare-fun Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2 () Term)
;;;;;;;;;;;;;;;;Typing for non-total arrows
;;; Fact-ids: Name Prims._assume; Namespace Prims
(assert (! (HasType Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2
Tm_type)
:named non_total_function_typing_Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2))
;;;;;;;;;;;;;;;;pre_typing_Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2
;;; Fact-ids: Name Prims._assume; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,29-637,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,29-637,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2))
:qid pre_typing_Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2))

:named pre_typing_Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2))
(declare-fun Prims._assume@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims._assume; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims._assume@tok
@x0)
(Prims._assume @x0))
 

:pattern ((ApplyTT Prims._assume@tok
@x0))
:qid token_correspondence_Prims._assume))

:named token_correspondence_Prims._assume))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims._assume; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims._assume@tok
Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims._assume@tok
@x1)
(Prims._assume @x1))
 

:pattern ((Prims._assume @x1))
:qid function_token_typing_Prims._assume.1))
)
 

:pattern ((ApplyTT @x0
Prims._assume@tok))
:qid function_token_typing_Prims._assume))

:named function_token_typing_Prims._assume))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims._assume; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(637,4-637,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims._assume @x0)
Prims.unit))
 

:pattern ((Prims._assume @x0))
:qid typing_Prims._assume))

:named typing_Prims._assume))

; </end encoding Prims._assume>


; <Start encoding 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 Prims.admit>


; <Start encoding Prims.magic>

(declare-fun Prims.magic (Term Term) Term)
;;;;;;;;;;;;;;;;_: Prims.unit -> a
(declare-fun Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb
;;; Fact-ids: Name Prims.magic; Namespace Prims
(assert (! (HasType Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb
Tm_type)
:named kinding_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.magic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,12-649,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,35-649,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))
:qid Prims_pre_typing_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))

:named Prims_pre_typing_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb
;;; Fact-ids: Name Prims.magic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,12-649,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,35-649,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,12-649,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,35-649,36)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Prims.unit))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x1))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,12-649,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,35-649,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))
:qid Prims_interpretation_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))

:named Prims_interpretation_Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))
(declare-fun Prims.magic@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.magic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.magic@tok
@x0)
@x1)
(Prims.magic @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.magic@tok
@x0)
@x1))
:qid token_correspondence_Prims.magic))

:named token_correspondence_Prims.magic))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.magic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.magic@tok
Tm_arrow_f5df98ce82fbcebbbdb844c958bee4fb))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.magic@tok
@x1)
@x2)
(Prims.magic @x1
@x2))
 

:pattern ((Prims.magic @x1
@x2))
:qid function_token_typing_Prims.magic.1))
)
 

:pattern ((ApplyTT @x0
Prims.magic@tok))
:qid function_token_typing_Prims.magic))

:named function_token_typing_Prims.magic))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.magic; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(649,4-649,9)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Prims.unit))
(HasType (Prims.magic @x0
@x1)
@x0))
 

:pattern ((Prims.magic @x0
@x1))
:qid typing_Prims.magic))

:named typing_Prims.magic))

; </end encoding Prims.magic>


; <Start encoding Prims.unsafe_coerce>

(declare-fun Prims.unsafe_coerce (Term Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> b
(declare-fun Tm_arrow_443ab41008720460b7a09e280558a60f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_443ab41008720460b7a09e280558a60f
;;; Fact-ids: Name Prims.unsafe_coerce; Namespace Prims
(assert (! (HasType Tm_arrow_443ab41008720460b7a09e280558a60f
Tm_type)
:named kinding_Tm_arrow_443ab41008720460b7a09e280558a60f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.unsafe_coerce; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,23-655,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,41-655,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_443ab41008720460b7a09e280558a60f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_443ab41008720460b7a09e280558a60f))
:qid Prims_pre_typing_Tm_arrow_443ab41008720460b7a09e280558a60f))

:named Prims_pre_typing_Tm_arrow_443ab41008720460b7a09e280558a60f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_443ab41008720460b7a09e280558a60f
;;; Fact-ids: Name Prims.unsafe_coerce; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,23-655,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,41-655,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_443ab41008720460b7a09e280558a60f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,23-655,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,41-655,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_443ab41008720460b7a09e280558a60f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,23-655,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,41-655,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_443ab41008720460b7a09e280558a60f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,23-655,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,41-655,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_443ab41008720460b7a09e280558a60f.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_443ab41008720460b7a09e280558a60f))
:qid Prims_interpretation_Tm_arrow_443ab41008720460b7a09e280558a60f))

:named Prims_interpretation_Tm_arrow_443ab41008720460b7a09e280558a60f))
(declare-fun Prims.unsafe_coerce@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.unsafe_coerce; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.unsafe_coerce@tok
@x0)
@x1)
@x2)
(Prims.unsafe_coerce @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.unsafe_coerce@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.unsafe_coerce))

:named token_correspondence_Prims.unsafe_coerce))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.unsafe_coerce; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.unsafe_coerce@tok
Tm_arrow_443ab41008720460b7a09e280558a60f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.unsafe_coerce@tok
@x1)
@x2)
@x3)
(Prims.unsafe_coerce @x1
@x2
@x3))
 

:pattern ((Prims.unsafe_coerce @x1
@x2
@x3))
:qid function_token_typing_Prims.unsafe_coerce.1))
)
 

:pattern ((ApplyTT @x0
Prims.unsafe_coerce@tok))
:qid function_token_typing_Prims.unsafe_coerce))

:named function_token_typing_Prims.unsafe_coerce))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.unsafe_coerce; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(655,4-655,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
@x0))
(HasType (Prims.unsafe_coerce @x0
@x1
@x2)
@x1))
 

:pattern ((Prims.unsafe_coerce @x0
@x1
@x2))
:qid typing_Prims.unsafe_coerce))

:named typing_Prims.unsafe_coerce))

; </end encoding Prims.unsafe_coerce>


; <Start encoding Prims.admitP>

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

(declare-fun Prims.admitP@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.admitP; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.admitP@tok
@x0)
(Prims.admitP @x0))
 

:pattern ((ApplyTT Prims.admitP@tok
@x0))
:qid token_correspondence_Prims.admitP))

:named token_correspondence_Prims.admitP))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.admitP; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.admitP@tok
Non_total_Tm_arrow_724d0dab46b8b51a1bb19d329f7fc4b2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.admitP@tok
@x1)
(Prims.admitP @x1))
 

:pattern ((Prims.admitP @x1))
:qid function_token_typing_Prims.admitP.1))
)
 

:pattern ((ApplyTT @x0
Prims.admitP@tok))
:qid function_token_typing_Prims.admitP))

:named function_token_typing_Prims.admitP))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.admitP; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(662,4-662,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.admitP @x0)
Prims.unit))
 

:pattern ((Prims.admitP @x0))
:qid typing_Prims.admitP))

:named typing_Prims.admitP))

; </end encoding Prims.admitP>


; <Skipped Prims._assert/>


; <Start encoding Prims._assert>

(declare-fun Prims._assert (Term) Term)
(declare-fun Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642 () Term)
;;;;;;;;;;;;;;;;Typing for non-total arrows
;;; Fact-ids: Name Prims._assert; Namespace Prims
(assert (! (HasType Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642
Tm_type)
:named non_total_function_typing_Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642))
;;;;;;;;;;;;;;;;pre_typing_Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642
;;; Fact-ids: Name Prims._assert; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(667,29-667,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642))
:qid pre_typing_Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642))

:named pre_typing_Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642))
(declare-fun Prims._assert@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims._assert; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims._assert@tok
@x0)
(Prims._assert @x0))
 

:pattern ((ApplyTT Prims._assert@tok
@x0))
:qid token_correspondence_Prims._assert))

:named token_correspondence_Prims._assert))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims._assert; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims._assert@tok
Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims._assert@tok
@x1)
(Prims._assert @x1))
 

:pattern ((Prims._assert @x1))
:qid function_token_typing_Prims._assert.1))
)
 

:pattern ((ApplyTT @x0
Prims._assert@tok))
:qid function_token_typing_Prims._assert))

:named function_token_typing_Prims._assert))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims._assert; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims._assert @x0)
Prims.unit))
 

:pattern ((Prims._assert @x0))
:qid typing_Prims._assert))

:named typing_Prims._assert))
;;;;;;;;;;;;;;;;Equation for Prims._assert
;;; Fact-ids: Name Prims._assert; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(668,4-668,11)
(forall ((@x0 Term))
 (! (= (Prims._assert @x0)
Tm_unit)
 

:pattern ((Prims._assert @x0))
:qid equation_Prims._assert))

:named equation_Prims._assert))

; </end encoding Prims._assert>


; <Skipped Prims.cut/>


; <Start encoding Prims.cut>

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

(declare-fun Prims.cut@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.cut; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.cut@tok
@x0)
(Prims.cut @x0))
 

:pattern ((ApplyTT Prims.cut@tok
@x0))
:qid token_correspondence_Prims.cut))

:named token_correspondence_Prims.cut))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.cut; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.cut@tok
Non_total_Tm_arrow_bb2d1b4bdb07c87bf5990ad3e5fd8642))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.cut@tok
@x1)
(Prims.cut @x1))
 

:pattern ((Prims.cut @x1))
:qid function_token_typing_Prims.cut.1))
)
 

:pattern ((ApplyTT @x0
Prims.cut@tok))
:qid function_token_typing_Prims.cut))

:named function_token_typing_Prims.cut))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.cut; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (Prims.cut @x0)
Prims.unit))
 

:pattern ((Prims.cut @x0))
:qid typing_Prims.cut))

:named typing_Prims.cut))
;;;;;;;;;;;;;;;;Equation for Prims.cut
;;; Fact-ids: Name Prims.cut; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(672,4-672,7)
(forall ((@x0 Term))
 (! (= (Prims.cut @x0)
Tm_unit)
 

:pattern ((Prims.cut @x0))
:qid equation_Prims.cut))

:named equation_Prims.cut))

; </end encoding Prims.cut>


; <Start encoding Prims.nat>

(declare-fun Prims.nat () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert (! (HasType Prims.nat
Tm_type)
:named function_token_typing_Prims.nat))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert (! (HasType Prims.nat
Tm_type)
:named typing_Prims.nat))
(declare-fun Tm_refine_542f9d4f129664613f2483a6c88bc7c2 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert (! (HasType Tm_refine_542f9d4f129664613f2483a6c88bc7c2
Tm_type)
:named refinement_kinding_Tm_refine_542f9d4f129664613f2483a6c88bc7c2))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(675,11-675,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(675,11-675,25)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_542f9d4f129664613f2483a6c88bc7c2)
(and (HasTypeFuel @u0
@x1
Prims.int)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(675,18-675,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(675,18-675,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))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Equation for Prims.nat
;;; Fact-ids: Name Prims.nat; Namespace Prims
(assert (! (= Prims.nat
Tm_refine_542f9d4f129664613f2483a6c88bc7c2)
:named equation_Prims.nat))

; </end encoding Prims.nat>


; <Start encoding Prims.pos>

(declare-fun Prims.pos () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert (! (HasType Prims.pos
Tm_type)
:named function_token_typing_Prims.pos))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert (! (HasType Prims.pos
Tm_type)
:named typing_Prims.pos))
(declare-fun Tm_refine_774ba3f728d91ead8ef40be66c9802e5 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert (! (HasType Tm_refine_774ba3f728d91ead8ef40be66c9802e5
Tm_type)
:named refinement_kinding_Tm_refine_774ba3f728d91ead8ef40be66c9802e5))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(678,11-678,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(678,11-678,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_774ba3f728d91ead8ef40be66c9802e5)
(and (HasTypeFuel @u0
@x1
Prims.int)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(678,18-678,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(678,18-678,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))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Equation for Prims.pos
;;; Fact-ids: Name Prims.pos; Namespace Prims
(assert (! (= Prims.pos
Tm_refine_774ba3f728d91ead8ef40be66c9802e5)
:named equation_Prims.pos))

; </end encoding Prims.pos>


; <Start encoding Prims.nonzero>

(declare-fun Prims.nonzero () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert (! (HasType Prims.nonzero
Tm_type)
:named function_token_typing_Prims.nonzero))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert (! (HasType Prims.nonzero
Tm_type)
:named typing_Prims.nonzero))
(declare-fun Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f () Term)
;;;;;;;;;;;;;;;;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 Prims.nonzero; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(681,15-681,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(681,15-681,29)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f)
(and (HasTypeFuel @u0
@x1
Prims.int)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(681,22-681,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(681,22-681,28)
(not (= @x1
(BoxInt 0)))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
:qid refinement_interpretation_Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))

:named refinement_interpretation_Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f))
;;;;;;;;;;;;;;;;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))
;;;;;;;;;;;;;;;;Equation for Prims.nonzero
;;; Fact-ids: Name Prims.nonzero; Namespace Prims
(assert (! (= Prims.nonzero
Tm_refine_0766302b68bb44ab7aff8c4d8be0b46f)
:named equation_Prims.nonzero))

; </end encoding Prims.nonzero>


; <Start encoding Prims.op_Modulus>

(declare-fun Prims.op_Modulus (Term Term) Term)
(declare-fun Prims.op_Modulus@tok () Term)
;;; Fact-ids: Name Prims.op_Modulus; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(692,4-692,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(692,4-692,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (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))
;;; Fact-ids: Name Prims.op_Modulus; Namespace Prims
(assert (! (IsTotFun Prims.op_Modulus@tok)
:named primitive_tot_fun_Prims.op_Modulus))
;;; Fact-ids: Name Prims.op_Modulus; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(692,4-692,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(692,4-692,14)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_Modulus@tok
@x0))
 

:pattern ((ApplyTT Prims.op_Modulus@tok
@x0))
:qid primitive_tot_fun_Prims.op_Modulus.1))

:named primitive_tot_fun_Prims.op_Modulus.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Modulus; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(692,4-692,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(692,4-692,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_Modulus@tok
@x0)
@x1)
(Prims.op_Modulus @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_Modulus@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_Modulus))

:named token_correspondence_Prims.op_Modulus))

; </end encoding Prims.op_Modulus>


; <Start encoding Prims.op_Division>

(declare-fun Prims.op_Division (Term Term) Term)
(declare-fun Prims.op_Division@tok () Term)
;;; Fact-ids: Name Prims.op_Division; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(698,4-698,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(698,4-698,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (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))
;;; Fact-ids: Name Prims.op_Division; Namespace Prims
(assert (! (IsTotFun Prims.op_Division@tok)
:named primitive_tot_fun_Prims.op_Division))
;;; Fact-ids: Name Prims.op_Division; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(698,4-698,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(698,4-698,15)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT Prims.op_Division@tok
@x0))
 

:pattern ((ApplyTT Prims.op_Division@tok
@x0))
:qid primitive_tot_fun_Prims.op_Division.1))

:named primitive_tot_fun_Prims.op_Division.1))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.op_Division; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(698,4-698,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(698,4-698,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.op_Division@tok
@x0)
@x1)
(Prims.op_Division @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.op_Division@tok
@x0)
@x1))
:qid token_correspondence_Prims.op_Division))

:named token_correspondence_Prims.op_Division))

; </end encoding Prims.op_Division>


; <Start encoding Prims.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)
;;;;;;;;;;;;;;;;x: Prims.nat -> Prims.pos
(declare-fun Tm_arrow_c331a0e032e021e1eaa359b3983de4f2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! (HasType Tm_arrow_c331a0e032e021e1eaa359b3983de4f2
Tm_type)
:named kinding_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,28-703,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,28-703,31)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c331a0e032e021e1eaa359b3983de4f2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))
:qid Prims_pre_typing_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))

:named Prims_pre_typing_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,28-703,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,28-703,31)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c331a0e032e021e1eaa359b3983de4f2)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,28-703,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,28-703,31)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.nat)
(HasType (ApplyTT @x0
@x1)
Prims.pos))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))
:qid Prims_interpretation_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))

:named Prims_interpretation_Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.pow2@tok
@x0)
(Prims.pow2 @x0))
 

:pattern ((ApplyTT Prims.pow2@tok
@x0))
:qid token_correspondence_Prims.pow2))

:named token_correspondence_Prims.pow2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.pow2@tok
Tm_arrow_c331a0e032e021e1eaa359b3983de4f2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.pow2@tok
@x1)
(Prims.pow2 @x1))
 

:pattern ((Prims.pow2 @x1))
:qid function_token_typing_Prims.pow2.1))
)
 

:pattern ((ApplyTT @x0
Prims.pow2@tok))
:qid function_token_typing_Prims.pow2))

:named function_token_typing_Prims.pow2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,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))
;;;;;;;;;;;;;;;;Equation for fuel-instrumented recursive function: Prims.pow2
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,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=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,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))
;;;;;;;;;;;;;;;;Typing correspondence of token to term
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,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))
;;;;;;;;;;;;;;;;Fuel token correspondence
;;; Fact-ids: Name Prims.pow2; Namespace Prims
(assert (! (and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12)
(forall ((@u0 Fuel) (@x1 Term))
 (! (= (ApplyTT (ApplyTF Prims.pow2.fuel_instrumented_token
@u0)
@x1)
(Prims.pow2.fuel_instrumented @u0
@x1))
 

:pattern ((ApplyTT (ApplyTF Prims.pow2.fuel_instrumented_token
@u0)
@x1))
:qid fuel_token_correspondence_Prims.pow2.fuel_instrumented_token))

(IsTotFun Prims.pow2.fuel_instrumented_token)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(703,8-703,12)
(forall ((@u0 Fuel))
 (! (IsTotFun (ApplyTF Prims.pow2.fuel_instrumented_token
@u0))
 

:pattern ((ApplyTF Prims.pow2.fuel_instrumented_token
@u0))
:qid fuel_token_correspondence_Prims.pow2.fuel_instrumented_token.1))
)
:named fuel_token_correspondence_Prims.pow2.fuel_instrumented_token))

; </end encoding Prims.pow2>


; <Start encoding Prims.min>

(declare-fun Prims.min (Term Term) Term)
;;;;;;;;;;;;;;;;x: Prims.int -> y: Prims.int -> Prims.int
(declare-fun Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! (HasType Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623
Tm_type)
:named kinding_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,24-559,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,29-709,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))
:qid Prims_pre_typing_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))

:named Prims_pre_typing_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,24-559,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,29-709,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,24-559,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,29-709,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Prims.int)
(HasType @x2
Prims.int))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.int))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(559,24-559,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,29-709,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.int)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))
:qid Prims_interpretation_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))

:named Prims_interpretation_Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))
(declare-fun Prims.min@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT Prims.min@tok
@x0)
@x1)
(Prims.min @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT Prims.min@tok
@x0)
@x1))
:qid token_correspondence_Prims.min))

:named token_correspondence_Prims.min))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.min@tok
Tm_arrow_47fc285d7b44e13bcb7e420cbfc55623))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT Prims.min@tok
@x1)
@x2)
(Prims.min @x1
@x2))
 

:pattern ((Prims.min @x1
@x2))
:qid function_token_typing_Prims.min.1))
)
 

:pattern ((ApplyTT @x0
Prims.min@tok))
:qid function_token_typing_Prims.min))

:named function_token_typing_Prims.min))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.int)
(HasType @x1
Prims.int))
(HasType (Prims.min @x0
@x1)
Prims.int))
 

:pattern ((Prims.min @x0
@x1))
:qid typing_Prims.min))

:named typing_Prims.min))
;;;;;;;;;;;;;;;;Equation for Prims.min
;;; Fact-ids: Name Prims.min; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(709,4-709,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (Prims.min @x0
@x1)
(let ((@lb2 (Prims.op_LessThanOrEqual @x0
@x1)))
(ite (= @lb2
(BoxBool true))
@x0
@x1)))
 

:pattern ((Prims.min @x0
@x1))
:qid equation_Prims.min))

:named equation_Prims.min))

; </end encoding Prims.min>


; <Start encoding Prims.abs>

(declare-fun Prims.abs (Term) Term)
;;;;;;;;;;;;;;;;x: Prims.int -> Prims.int
(declare-fun Tm_arrow_35447810753695c4fe25c93af1251992 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_35447810753695c4fe25c93af1251992
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! (HasType Tm_arrow_35447810753695c4fe25c93af1251992
Tm_type)
:named kinding_Tm_arrow_35447810753695c4fe25c93af1251992))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,23-712,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,23-712,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_35447810753695c4fe25c93af1251992)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_35447810753695c4fe25c93af1251992))
:qid Prims_pre_typing_Tm_arrow_35447810753695c4fe25c93af1251992))

:named Prims_pre_typing_Tm_arrow_35447810753695c4fe25c93af1251992))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_35447810753695c4fe25c93af1251992
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,23-712,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,23-712,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_35447810753695c4fe25c93af1251992)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,23-712,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,23-712,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.int)
(HasType (ApplyTT @x0
@x1)
Prims.int))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_35447810753695c4fe25c93af1251992.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_35447810753695c4fe25c93af1251992))
:qid Prims_interpretation_Tm_arrow_35447810753695c4fe25c93af1251992))

:named Prims_interpretation_Tm_arrow_35447810753695c4fe25c93af1251992))
(declare-fun Prims.abs@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.abs@tok
@x0)
(Prims.abs @x0))
 

:pattern ((ApplyTT Prims.abs@tok
@x0))
:qid token_correspondence_Prims.abs))

:named token_correspondence_Prims.abs))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.abs@tok
Tm_arrow_35447810753695c4fe25c93af1251992))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.abs@tok
@x1)
(Prims.abs @x1))
 

:pattern ((Prims.abs @x1))
:qid function_token_typing_Prims.abs.1))
)
 

:pattern ((ApplyTT @x0
Prims.abs@tok))
:qid function_token_typing_Prims.abs))

:named function_token_typing_Prims.abs))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.int)
(HasType (Prims.abs @x0)
Prims.int))
 

:pattern ((Prims.abs @x0))
:qid typing_Prims.abs))

:named typing_Prims.abs))
;;;;;;;;;;;;;;;;Equation for Prims.abs
;;; Fact-ids: Name Prims.abs; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(712,4-712,7)
(forall ((@x0 Term))
 (! (= (Prims.abs @x0)
(let ((@lb1 (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0))))
(ite (= @lb1
(BoxBool true))
@x0
(Prims.op_Minus @x0))))
 

:pattern ((Prims.abs @x0))
:qid equation_Prims.abs))

:named equation_Prims.abs))

; </end encoding Prims.abs>


; <Start encoding Prims.string_of_bool>

(declare-fun Prims.string_of_bool (Term) Term)
;;;;;;;;;;;;;;;;_: Prims.bool -> Prims.string
(declare-fun Tm_arrow_e86b54405c2a58719f5e8112efd48c09 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e86b54405c2a58719f5e8112efd48c09
;;; Fact-ids: Name Prims.string_of_bool; Namespace Prims
(assert (! (HasType Tm_arrow_e86b54405c2a58719f5e8112efd48c09
Tm_type)
:named kinding_Tm_arrow_e86b54405c2a58719f5e8112efd48c09))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.string_of_bool; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,32-718,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,32-718,38)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e86b54405c2a58719f5e8112efd48c09)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e86b54405c2a58719f5e8112efd48c09))
:qid Prims_pre_typing_Tm_arrow_e86b54405c2a58719f5e8112efd48c09))

:named Prims_pre_typing_Tm_arrow_e86b54405c2a58719f5e8112efd48c09))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e86b54405c2a58719f5e8112efd48c09
;;; Fact-ids: Name Prims.string_of_bool; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,32-718,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,32-718,38)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e86b54405c2a58719f5e8112efd48c09)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,32-718,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,32-718,38)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.bool)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_e86b54405c2a58719f5e8112efd48c09.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e86b54405c2a58719f5e8112efd48c09))
:qid Prims_interpretation_Tm_arrow_e86b54405c2a58719f5e8112efd48c09))

:named Prims_interpretation_Tm_arrow_e86b54405c2a58719f5e8112efd48c09))
(declare-fun Prims.string_of_bool@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.string_of_bool; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.string_of_bool@tok
@x0)
(Prims.string_of_bool @x0))
 

:pattern ((ApplyTT Prims.string_of_bool@tok
@x0))
:qid token_correspondence_Prims.string_of_bool))

:named token_correspondence_Prims.string_of_bool))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.string_of_bool; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.string_of_bool@tok
Tm_arrow_e86b54405c2a58719f5e8112efd48c09))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.string_of_bool@tok
@x1)
(Prims.string_of_bool @x1))
 

:pattern ((Prims.string_of_bool @x1))
:qid function_token_typing_Prims.string_of_bool.1))
)
 

:pattern ((ApplyTT @x0
Prims.string_of_bool@tok))
:qid function_token_typing_Prims.string_of_bool))

:named function_token_typing_Prims.string_of_bool))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.string_of_bool; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(718,4-718,18)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.bool)
(HasType (Prims.string_of_bool @x0)
Prims.string))
 

:pattern ((Prims.string_of_bool @x0))
:qid typing_Prims.string_of_bool))

:named typing_Prims.string_of_bool))

; </end encoding Prims.string_of_bool>


; <Start encoding Prims.string_of_int>

(declare-fun Prims.string_of_int (Term) Term)
;;;;;;;;;;;;;;;;_: Prims.int -> Prims.string
(declare-fun Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b
;;; Fact-ids: Name Prims.string_of_int; Namespace Prims
(assert (! (HasType Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b
Tm_type)
:named kinding_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.string_of_int; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,30-722,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,30-722,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))
:qid Prims_pre_typing_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))

:named Prims_pre_typing_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b
;;; Fact-ids: Name Prims.string_of_int; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,30-722,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,30-722,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,30-722,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,30-722,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.int)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))
:qid Prims_interpretation_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))

:named Prims_interpretation_Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))
(declare-fun Prims.string_of_int@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.string_of_int; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17)
(forall ((@x0 Term))
 (! (= (ApplyTT Prims.string_of_int@tok
@x0)
(Prims.string_of_int @x0))
 

:pattern ((ApplyTT Prims.string_of_int@tok
@x0))
:qid token_correspondence_Prims.string_of_int))

:named token_correspondence_Prims.string_of_int))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.string_of_int; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.string_of_int@tok
Tm_arrow_2bc066ec63734c94a3c008e1e72cae2b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17)
(forall ((@x1 Term))
 (! (= (ApplyTT Prims.string_of_int@tok
@x1)
(Prims.string_of_int @x1))
 

:pattern ((Prims.string_of_int @x1))
:qid function_token_typing_Prims.string_of_int.1))
)
 

:pattern ((ApplyTT @x0
Prims.string_of_int@tok))
:qid function_token_typing_Prims.string_of_int))

:named function_token_typing_Prims.string_of_int))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.string_of_int; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(722,4-722,17)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.int)
(HasType (Prims.string_of_int @x0)
Prims.string))
 

:pattern ((Prims.string_of_int @x0))
:qid typing_Prims.string_of_int))

:named typing_Prims.string_of_int))

; </end encoding Prims.string_of_int>


; <Start encoding Prims.labeled>

(declare-fun Prims.labeled (Term Term Term) Term)
;;;;;;;;;;;;;;;;r: Prims.range -> msg: Prims.string -> b: Type -> Type
(declare-fun Tm_arrow_04aa773f28f907e6a0b5741576bf5493 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_04aa773f28f907e6a0b5741576bf5493
;;; Fact-ids: Name Prims.labeled; Namespace Prims
(assert (! (HasType Tm_arrow_04aa773f28f907e6a0b5741576bf5493
Tm_type)
:named kinding_Tm_arrow_04aa773f28f907e6a0b5741576bf5493))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Prims.labeled; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_04aa773f28f907e6a0b5741576bf5493)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_04aa773f28f907e6a0b5741576bf5493))
:qid Prims_pre_typing_Tm_arrow_04aa773f28f907e6a0b5741576bf5493))

:named Prims_pre_typing_Tm_arrow_04aa773f28f907e6a0b5741576bf5493))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_04aa773f28f907e6a0b5741576bf5493
;;; Fact-ids: Name Prims.labeled; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_04aa773f28f907e6a0b5741576bf5493)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Prims.range)
(HasType @x2
Prims.string)
(HasType @x3
Tm_type))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid Prims_interpretation_Tm_arrow_04aa773f28f907e6a0b5741576bf5493.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.range)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid Prims_interpretation_Tm_arrow_04aa773f28f907e6a0b5741576bf5493.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,49-727,53)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Prims.range)
(HasType @x2
Prims.string))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid Prims_interpretation_Tm_arrow_04aa773f28f907e6a0b5741576bf5493.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_04aa773f28f907e6a0b5741576bf5493))
:qid Prims_interpretation_Tm_arrow_04aa773f28f907e6a0b5741576bf5493))

:named Prims_interpretation_Tm_arrow_04aa773f28f907e6a0b5741576bf5493))
(declare-fun Prims.labeled@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Prims.labeled; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.labeled@tok
@x0)
@x1)
@x2)
(Prims.labeled @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.labeled@tok
@x0)
@x1)
@x2))
:qid token_correspondence_Prims.labeled))

:named token_correspondence_Prims.labeled))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Prims.labeled; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Prims.labeled@tok
Tm_arrow_04aa773f28f907e6a0b5741576bf5493))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.labeled@tok
@x1)
@x2)
@x3)
(Prims.labeled @x1
@x2
@x3))
 

:pattern ((Prims.labeled @x1
@x2
@x3))
:qid function_token_typing_Prims.labeled.1))
)
 

:pattern ((ApplyTT @x0
Prims.labeled@tok))
:qid function_token_typing_Prims.labeled))

:named function_token_typing_Prims.labeled))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.labeled; Namespace Prims
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(727,4-727,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Prims.range)
(HasType @x1
Prims.string)
(HasType @x2
Tm_type))
(HasType (Prims.labeled @x0
@x1
@x2)
Tm_type))
 

:pattern ((Prims.labeled @x0
@x1
@x2))
:qid typing_Prims.labeled))

:named typing_Prims.labeled))

; </end encoding Prims.labeled>


; <Start encoding Prims.__cache_version_number__>

(declare-fun Prims.__cache_version_number__ () Term)
;;;;;;;;;;;;;;;;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__))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Prims.__cache_version_number__; Namespace Prims
(assert (! (HasType Prims.__cache_version_number__
Prims.int)
:named typing_Prims.__cache_version_number__))

; </end encoding Prims.__cache_version_number__>


; End Externals for module Prims

;;; End module Prims (1336 decls; total size 433973)

;;; Start module FStar.Pervasives.Native

; Externals for module FStar.Pervasives.Native


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.option (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.option@x0 (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: 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: Some
(declare-fun FStar.Pervasives.Native.Some@tok () Term)
;;;;;;;;;;;;;;;;FStar.Pervasives.Native.option a
(declare-fun Tm_arrow_48b914114ec9f2f1caadf0f6848a9741 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_48b914114ec9f2f1caadf0f6848a9741
Tm_type)
:named kinding_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,11-32,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,11-32,19)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_48b914114ec9f2f1caadf0f6848a9741)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,11-32,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,11-32,19)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_48b914114ec9f2f1caadf0f6848a9741)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,11-32,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,11-32,19)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
(FStar.Pervasives.Native.option @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))
;;;;;;;;;;;;;;;;v: a -> FStar.Pervasives.Native.option a
(declare-fun Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752
Tm_type)
:named kinding_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(FStar.Pervasives.Native.option @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,19-33,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))

; <Start encoding FStar.Pervasives.Native.option>


; <start constructor FStar.Pervasives.Native.option>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11)
(forall ((@x0 Term))
 (! (= 101
(Term_constr_id (FStar.Pervasives.Native.option @x0)))
 

:pattern ((FStar.Pervasives.Native.option @x0))
:qid constructor_distinct_FStar.Pervasives.Native.option))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.option))))

; </end constructor FStar.Pervasives.Native.option>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (= 102
(Term_constr_id FStar.Pervasives.Native.option@tok))
:named fresh_token_FStar.Pervasives.Native.option@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.Native.option@tok
@x0)
(FStar.Pervasives.Native.option @x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.option@tok
@x0))

:pattern ((FStar.Pervasives.Native.option @x0))
:qid token_correspondence_FStar.Pervasives.Native.option@tok))

:named token_correspondence_FStar.Pervasives.Native.option@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.option@tok))
:named pre_kinding_FStar.Pervasives.Native.option@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.option@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.Native.option @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.option @x0))
:qid kinding_FStar.Pervasives.Native.option@tok))
)
:named kinding_FStar.Pervasives.Native.option@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.option @x2))
(= (FStar.Pervasives.Native.option @x2)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.option @x2)))
:qid FStar.Pervasives.Native_pretyping_b53dbd183c526bc5d0f20d7b966ae125))

:named FStar.Pervasives.Native_pretyping_b53dbd183c526bc5d0f20d7b966ae125))

; </end encoding FStar.Pervasives.Native.option>


; <Start encoding FStar.Pervasives.Native.None>


; <start constructor FStar.Pervasives.Native.None>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term))
 (! (= 108
(Term_constr_id (FStar.Pervasives.Native.None @x0)))
 

:pattern ((FStar.Pervasives.Native.None @x0))
:qid constructor_distinct_FStar.Pervasives.Native.None))

:named constructor_distinct_FStar.Pervasives.Native.None))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.Native.None_a (FStar.Pervasives.Native.None @x0))
@x0)
 

:pattern ((FStar.Pervasives.Native.None @x0))
:qid projection_inverse_FStar.Pervasives.Native.None_a))

:named projection_inverse_FStar.Pervasives.Native.None_a))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (= 111
(Term_constr_id FStar.Pervasives.Native.None@tok))
:named fresh_token_FStar.Pervasives.Native.None@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.None@tok
Tm_arrow_48b914114ec9f2f1caadf0f6848a9741))
 

:pattern ((ApplyTT FStar.Pervasives.Native.None@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.None@tok))
:qid typing_tok_FStar.Pervasives.Native.None@tok))

:named typing_tok_FStar.Pervasives.Native.None@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.Native.None@tok
@x0)
(FStar.Pervasives.Native.None @x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.None@tok
@x0))
:qid equality_tok_FStar.Pervasives.Native.None@tok))

:named equality_tok_FStar.Pervasives.Native.None@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
(FStar.Pervasives.Native.None @x1)
(FStar.Pervasives.Native.option @x1)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.None @x1)
(FStar.Pervasives.Native.option @x1)))
:qid data_typing_intro_FStar.Pervasives.Native.None@tok))

:named data_typing_intro_FStar.Pervasives.Native.None@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.None @x1)
(FStar.Pervasives.Native.option @x2))
(and (HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x1
Tm_type)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.None @x1)
(FStar.Pervasives.Native.option @x2)))
:qid data_elim_FStar.Pervasives.Native.None))

:named data_elim_FStar.Pervasives.Native.None))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! true
:named subterm_ordering_FStar.Pervasives.Native.None))

; </end encoding FStar.Pervasives.Native.None>


; <Start encoding FStar.Pervasives.Native.Some>


; <start constructor FStar.Pervasives.Native.Some>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= 113
(Term_constr_id (FStar.Pervasives.Native.Some @x0
@x1)))
 

:pattern ((FStar.Pervasives.Native.Some @x0
@x1))
:qid constructor_distinct_FStar.Pervasives.Native.Some))

:named constructor_distinct_FStar.Pervasives.Native.Some))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Native.Some_a (FStar.Pervasives.Native.Some @x0
@x1))
@x0)
 

:pattern ((FStar.Pervasives.Native.Some @x0
@x1))
:qid projection_inverse_FStar.Pervasives.Native.Some_a))

:named projection_inverse_FStar.Pervasives.Native.Some_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Native.Some_v (FStar.Pervasives.Native.Some @x0
@x1))
@x1)
 

:pattern ((FStar.Pervasives.Native.Some @x0
@x1))
:qid projection_inverse_FStar.Pervasives.Native.Some_v))

:named projection_inverse_FStar.Pervasives.Native.Some_v))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! (= 116
(Term_constr_id FStar.Pervasives.Native.Some@tok))
:named fresh_token_FStar.Pervasives.Native.Some@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Some@tok
Tm_arrow_b93a364b5144c2a5f3e9d1ea7b881752))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Some@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Some@tok))
:qid typing_tok_FStar.Pervasives.Native.Some@tok))

:named typing_tok_FStar.Pervasives.Native.Some@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.Some@tok
@x0)
@x1)
(FStar.Pervasives.Native.Some @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.Some@tok
@x0)
@x1))
:qid equality_tok_FStar.Pervasives.Native.Some@tok))

:named equality_tok_FStar.Pervasives.Native.Some@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
@x1))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Some @x1
@x2)
(FStar.Pervasives.Native.option @x1)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Some @x1
@x2)
(FStar.Pervasives.Native.option @x1)))
:qid data_typing_intro_FStar.Pervasives.Native.Some@tok))

:named data_typing_intro_FStar.Pervasives.Native.Some@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Some @x1
@x2)
(FStar.Pervasives.Native.option @x3))
(and (HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x2
@x3)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
@x1)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Some @x1
@x2)
(FStar.Pervasives.Native.option @x3)))
:qid data_elim_FStar.Pervasives.Native.Some))

:named data_elim_FStar.Pervasives.Native.Some))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Some @x1
@x2)
(FStar.Pervasives.Native.option @x3))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x2
(FStar.Pervasives.Native.Some @x1
@x2))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Some @x1
@x2)
(FStar.Pervasives.Native.option @x3)))
:qid subterm_ordering_FStar.Pervasives.Native.Some))

:named subterm_ordering_FStar.Pervasives.Native.Some))

; </end encoding FStar.Pervasives.Native.Some>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.option; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.None; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,5-31,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(FStar.Pervasives.Native.option @x2))
(or (and (is-FStar.Pervasives.Native.None @x1)
(= @x2
(FStar.Pervasives.Native.None_a @x1)))
(and (is-FStar.Pervasives.Native.Some @x1)
(= @x2
(FStar.Pervasives.Native.Some_a @x1)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
@x1
(FStar.Pervasives.Native.option @x2)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.option))

:named fuel_guarded_inversion_FStar.Pervasives.Native.option))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.option__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: option__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.option__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (implies (and (HasType @x0
Tm_type)
(Valid (Prims.hasEq @x0)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.option @x0))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.option @x0)))
:qid assumption_FStar.Pervasives.Native.option__uu___haseq))
:named assumption_FStar.Pervasives.Native.option__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_None>

(declare-fun FStar.Pervasives.Native.uu___is_None (Term Term) Term)
;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.Native.option a -> Prims.bool
(declare-fun Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa
Tm_type)
:named kinding_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa)
(and (forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.Native.option @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa.2))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))
(declare-fun FStar.Pervasives.Native.uu___is_None@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_None@tok
@x0)
@x1)
(FStar.Pervasives.Native.uu___is_None @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_None@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_None))

:named token_correspondence_FStar.Pervasives.Native.uu___is_None))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_None@tok
Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_None@tok
@x1)
@x2)
(FStar.Pervasives.Native.uu___is_None @x1
@x2))
 

:pattern ((FStar.Pervasives.Native.uu___is_None @x1
@x2))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_None.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_None@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_None))

:named function_token_typing_FStar.Pervasives.Native.uu___is_None))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.Native.option @x0)))
(HasType (FStar.Pervasives.Native.uu___is_None @x0
@x1)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_None @x0
@x1))
:qid typing_FStar.Pervasives.Native.uu___is_None))

:named typing_FStar.Pervasives.Native.uu___is_None))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_None; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(32,4-32,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Native.uu___is_None @x0
@x1)
(BoxBool (is-FStar.Pervasives.Native.None @x1)))
 

:pattern ((FStar.Pervasives.Native.uu___is_None @x0
@x1))
:qid disc_equation_FStar.Pervasives.Native.None))

:named disc_equation_FStar.Pervasives.Native.None))

; </end encoding FStar.Pervasives.Native.uu___is_None>


; <Skipped FStar.Pervasives.Native.uu___is_None/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Some@tok
@x0)
@x1)
(FStar.Pervasives.Native.uu___is_Some @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Some@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Some))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Some))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Some@tok
Tm_arrow_f1a97bcd6ba9b40d22609b756f183afa))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Some@tok
@x1)
@x2)
(FStar.Pervasives.Native.uu___is_Some @x1
@x2))
 

:pattern ((FStar.Pervasives.Native.uu___is_Some @x1
@x2))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Some.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Some@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Some))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Some))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.Native.option @x0)))
(HasType (FStar.Pervasives.Native.uu___is_Some @x0
@x1)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Some @x0
@x1))
:qid typing_FStar.Pervasives.Native.uu___is_Some))

:named typing_FStar.Pervasives.Native.uu___is_Some))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Some; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Some @x0
@x1)
(BoxBool (is-FStar.Pervasives.Native.Some @x1)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Some @x0
@x1))
:qid disc_equation_FStar.Pervasives.Native.Some))

:named disc_equation_FStar.Pervasives.Native.Some))

; </end encoding FStar.Pervasives.Native.uu___is_Some>


; <Skipped FStar.Pervasives.Native.uu___is_Some/>


; <Start encoding FStar.Pervasives.Native.__proj__Some__item__v>

(declare-fun Tm_refine_4d5241eb6fe198666a8101195bbd4a2a (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_4d5241eb6fe198666a8101195bbd4a2a))

:named refinement_kinding_Tm_refine_4d5241eb6fe198666a8101195bbd4a2a))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x2))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.option @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(BoxBool_proj_0 (FStar.Pervasives.Native.uu___is_Some @x2
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x2)))
:qid refinement_interpretation_Tm_refine_4d5241eb6fe198666a8101195bbd4a2a))

:named refinement_interpretation_Tm_refine_4d5241eb6fe198666a8101195bbd4a2a))
;;;;;;;;;;;;;;;;haseq for Tm_refine_4d5241eb6fe198666a8101195bbd4a2a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,4-33,8)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x0)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.option @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x0))))
:qid haseqTm_refine_4d5241eb6fe198666a8101195bbd4a2a))

:named haseqTm_refine_4d5241eb6fe198666a8101195bbd4a2a))
(declare-fun FStar.Pervasives.Native.__proj__Some__item__v (Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.Native.option a {Some? _} -> a
(declare-fun Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411
Tm_type)
:named kinding_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x1))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(31,13-31,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))
(declare-fun FStar.Pervasives.Native.__proj__Some__item__v@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Some__item__v@tok
@x0)
@x1)
(FStar.Pervasives.Native.__proj__Some__item__v @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Some__item__v@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Some__item__v))

:named token_correspondence_FStar.Pervasives.Native.__proj__Some__item__v))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Some__item__v@tok
Tm_arrow_1b1398c011ff53e4194fc2ec00c7b411))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Some__item__v@tok
@x1)
@x2)
(FStar.Pervasives.Native.__proj__Some__item__v @x1
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Some__item__v @x1
@x2))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Some__item__v.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Some__item__v@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Some__item__v))

:named function_token_typing_FStar.Pervasives.Native.__proj__Some__item__v))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_refine_4d5241eb6fe198666a8101195bbd4a2a @x0)))
(HasType (FStar.Pervasives.Native.__proj__Some__item__v @x0
@x1)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Some__item__v @x0
@x1))
:qid typing_FStar.Pervasives.Native.__proj__Some__item__v))

:named typing_FStar.Pervasives.Native.__proj__Some__item__v))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Some__item__v; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(33,11-33,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Native.__proj__Some__item__v @x0
@x1)
(FStar.Pervasives.Native.Some_v @x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Some__item__v @x0
@x1))
:qid proj_equation_FStar.Pervasives.Native.Some_v))

:named proj_equation_FStar.Pervasives.Native.Some_v))

; </end encoding FStar.Pervasives.Native.__proj__Some__item__v>


; <Skipped FStar.Pervasives.Native.__proj__Some__item__v/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple2 (Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple2@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple2@x1 (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: Mktuple2
(declare-fun FStar.Pervasives.Native.Mktuple2@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> 'a * 'b
(declare-fun Tm_arrow_4054cc0a51327db54c2ed9ba3376a093 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_4054cc0a51327db54c2ed9ba3376a093
Tm_type)
:named kinding_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_4054cc0a51327db54c2ed9ba3376a093)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_4054cc0a51327db54c2ed9ba3376a093)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1)
(HasType @x4
@x2))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.tuple2 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,53-59,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))

; <Start encoding FStar.Pervasives.Native.tuple2>


; <start constructor FStar.Pervasives.Native.tuple2>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= 125
(Term_constr_id (FStar.Pervasives.Native.tuple2 @x0
@x1)))
 

:pattern ((FStar.Pervasives.Native.tuple2 @x0
@x1))
:qid constructor_distinct_FStar.Pervasives.Native.tuple2))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple2))))

; </end constructor FStar.Pervasives.Native.tuple2>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (= 126
(Term_constr_id FStar.Pervasives.Native.tuple2@tok))
:named fresh_token_FStar.Pervasives.Native.tuple2@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple2@tok
@x0)
@x1)
(FStar.Pervasives.Native.tuple2 @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple2@tok
@x0)
@x1))

:pattern ((FStar.Pervasives.Native.tuple2 @x0
@x1))
:qid token_correspondence_FStar.Pervasives.Native.tuple2@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple2@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple2@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple2@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple2@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple2@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple2@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple2@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.Native.tuple2 @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple2 @x0
@x1))
:qid kinding_FStar.Pervasives.Native.tuple2@tok.1))
)
:named kinding_FStar.Pervasives.Native.tuple2@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple2 @x2
@x3))
(= (FStar.Pervasives.Native.tuple2 @x2
@x3)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple2 @x2
@x3)))
:qid FStar.Pervasives.Native_pretyping_4894c30cf477acf9a27e7a844279eb08))

:named FStar.Pervasives.Native_pretyping_4894c30cf477acf9a27e7a844279eb08))

; </end encoding FStar.Pervasives.Native.tuple2>


; <Start encoding FStar.Pervasives.Native.Mktuple2>


; <start constructor FStar.Pervasives.Native.Mktuple2>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= 132
(Term_constr_id (FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3)))
 

:pattern ((FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple2))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.Mktuple2__a (FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple2__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple2__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.Mktuple2__b (FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple2__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple2__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.Mktuple2__1 (FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple2__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple2__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.Mktuple2__2 (FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple2__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple2__2))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (= 135
(Term_constr_id FStar.Pervasives.Native.Mktuple2@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple2@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple2@tok
Tm_arrow_4054cc0a51327db54c2ed9ba3376a093))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple2@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple2@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple2@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple2@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple2@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.Mktuple2 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple2@tok
@x0)
@x1)
@x2)
@x3))
:qid equality_tok_FStar.Pervasives.Native.Mktuple2@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple2@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1)
(HasTypeFuel @u0
@x4
@x2))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.tuple2 @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.tuple2 @x1
@x2)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple2@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple2@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.tuple2 @x5
@x6))
(and (HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x4
@x6)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x3
@x5)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1)
(HasTypeFuel @u0
@x4
@x2)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.tuple2 @x5
@x6)))
:qid data_elim_FStar.Pervasives.Native.Mktuple2))

:named data_elim_FStar.Pervasives.Native.Mktuple2))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.tuple2 @x5
@x6))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x4
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple2 @x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.tuple2 @x5
@x6)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple2))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple2))

; </end encoding FStar.Pervasives.Native.Mktuple2>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,5-59,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple2 @x2
@x3))
(and (is-FStar.Pervasives.Native.Mktuple2 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple2__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple2__b @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple2 @x2
@x3)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple2))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple2))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple2__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple2__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple2__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple2 @x0
@x1))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple2 @x0
@x1)))
:qid assumption_FStar.Pervasives.Native.tuple2__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple2__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple2>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple2 (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ('a * 'b) -> Prims.bool
(declare-fun Tm_arrow_eff71eeee4474e017e02350f86f54756 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_eff71eeee4474e017e02350f86f54756
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_eff71eeee4474e017e02350f86f54756
Tm_type)
:named kinding_Tm_arrow_eff71eeee4474e017e02350f86f54756))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_eff71eeee4474e017e02350f86f54756)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_eff71eeee4474e017e02350f86f54756))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_eff71eeee4474e017e02350f86f54756))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_eff71eeee4474e017e02350f86f54756))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_eff71eeee4474e017e02350f86f54756
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_eff71eeee4474e017e02350f86f54756)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple2 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eff71eeee4474e017e02350f86f54756.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eff71eeee4474e017e02350f86f54756.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eff71eeee4474e017e02350f86f54756.3))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_eff71eeee4474e017e02350f86f54756))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eff71eeee4474e017e02350f86f54756))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_eff71eeee4474e017e02350f86f54756))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple2@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Native.uu___is_Mktuple2 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple2@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple2))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple2@tok
Tm_arrow_eff71eeee4474e017e02350f86f54756))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple2@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.uu___is_Mktuple2 @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple2 @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple2@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple2))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.Native.tuple2 @x0
@x1)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple2 @x0
@x1
@x2)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple2 @x0
@x1
@x2))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple2))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple2))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,22-59,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple2 @x0
@x1
@x2)
(BoxBool (is-FStar.Pervasives.Native.Mktuple2 @x2)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple2 @x0
@x1
@x2))
:qid disc_equation_FStar.Pervasives.Native.Mktuple2))

:named disc_equation_FStar.Pervasives.Native.Mktuple2))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple2>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple2/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple2__item___1>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___1 (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ('a * 'b) -> 'a
(declare-fun Tm_arrow_b8cce376a4a678a51298a0f3945f25ce () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_b8cce376a4a678a51298a0f3945f25ce
Tm_type)
:named kinding_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_b8cce376a4a678a51298a0f3945f25ce)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_b8cce376a4a678a51298a0f3945f25ce)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple2 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,12-59,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple2__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple2__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok
Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple2__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple2__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple2__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple2__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.Native.tuple2 @x0
@x1)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x0
@x1
@x2)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x0
@x1
@x2))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple2__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple2__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,33-59,35)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x0
@x1
@x2)
(FStar.Pervasives.Native.Mktuple2__1 @x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x0
@x1
@x2))
:qid proj_equation_FStar.Pervasives.Native.Mktuple2__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple2__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple2__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple2__item___1/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple2__item___2>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___2 (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ('a * 'b) -> 'b
(declare-fun Tm_arrow_d952d001575ecb20c572af535c88dd2d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_d952d001575ecb20c572af535c88dd2d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_d952d001575ecb20c572af535c88dd2d
Tm_type)
:named kinding_Tm_arrow_d952d001575ecb20c572af535c88dd2d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_d952d001575ecb20c572af535c88dd2d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_d952d001575ecb20c572af535c88dd2d))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_d952d001575ecb20c572af535c88dd2d))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_d952d001575ecb20c572af535c88dd2d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_d952d001575ecb20c572af535c88dd2d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_d952d001575ecb20c572af535c88dd2d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple2 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d952d001575ecb20c572af535c88dd2d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d952d001575ecb20c572af535c88dd2d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,15-59,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d952d001575ecb20c572af535c88dd2d.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_d952d001575ecb20c572af535c88dd2d))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d952d001575ecb20c572af535c88dd2d))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_d952d001575ecb20c572af535c88dd2d))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple2__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple2__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok
Tm_arrow_d952d001575ecb20c572af535c88dd2d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple2__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple2__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple2__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple2__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.Native.tuple2 @x0
@x1)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x0
@x1
@x2)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x0
@x1
@x2))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple2__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple2__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple2__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(59,43-59,45)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x0
@x1
@x2)
(FStar.Pervasives.Native.Mktuple2__2 @x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x0
@x1
@x2))
:qid proj_equation_FStar.Pervasives.Native.Mktuple2__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple2__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple2__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple2__item___2/>


; <Start encoding FStar.Pervasives.Native.fst>

(declare-fun FStar.Pervasives.Native.fst (Term Term Term) Term)

(declare-fun FStar.Pervasives.Native.fst@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.fst; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.fst@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Native.fst @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.fst@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.Native.fst))

:named token_correspondence_FStar.Pervasives.Native.fst))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.fst; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.fst@tok
Tm_arrow_b8cce376a4a678a51298a0f3945f25ce))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.fst@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.fst @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.Native.fst @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.Native.fst.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.fst@tok))
:qid function_token_typing_FStar.Pervasives.Native.fst))

:named function_token_typing_FStar.Pervasives.Native.fst))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.fst; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.Native.tuple2 @x0
@x1)))
(HasType (FStar.Pervasives.Native.fst @x0
@x1
@x2)
@x0))
 

:pattern ((FStar.Pervasives.Native.fst @x0
@x1
@x2))
:qid typing_FStar.Pervasives.Native.fst))

:named typing_FStar.Pervasives.Native.fst))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.Native.fst
;;; Fact-ids: Name FStar.Pervasives.Native.fst; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(62,4-62,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Native.fst @x0
@x1
@x2)
(FStar.Pervasives.Native.__proj__Mktuple2__item___1 @x0
@x1
@x2))
 

:pattern ((FStar.Pervasives.Native.fst @x0
@x1
@x2))
:qid equation_FStar.Pervasives.Native.fst))

:named equation_FStar.Pervasives.Native.fst))

; </end encoding FStar.Pervasives.Native.fst>


; <Start encoding FStar.Pervasives.Native.snd>

(declare-fun FStar.Pervasives.Native.snd (Term Term Term) Term)

(declare-fun FStar.Pervasives.Native.snd@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.snd; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.snd@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Native.snd @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.snd@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.Native.snd))

:named token_correspondence_FStar.Pervasives.Native.snd))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.snd; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.snd@tok
Tm_arrow_d952d001575ecb20c572af535c88dd2d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.snd@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.snd @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.Native.snd @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.Native.snd.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.snd@tok))
:qid function_token_typing_FStar.Pervasives.Native.snd))

:named function_token_typing_FStar.Pervasives.Native.snd))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.snd; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.Native.tuple2 @x0
@x1)))
(HasType (FStar.Pervasives.Native.snd @x0
@x1
@x2)
@x1))
 

:pattern ((FStar.Pervasives.Native.snd @x0
@x1
@x2))
:qid typing_FStar.Pervasives.Native.snd))

:named typing_FStar.Pervasives.Native.snd))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.Native.snd
;;; Fact-ids: Name FStar.Pervasives.Native.snd; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(63,4-63,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Native.snd @x0
@x1
@x2)
(FStar.Pervasives.Native.__proj__Mktuple2__item___2 @x0
@x1
@x2))
 

:pattern ((FStar.Pervasives.Native.snd @x0
@x1
@x2))
:qid equation_FStar.Pervasives.Native.snd))

:named equation_FStar.Pervasives.Native.snd))

; </end encoding FStar.Pervasives.Native.snd>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple3 (Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple3@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple3@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple3@x2 (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: Mktuple3
(declare-fun FStar.Pervasives.Native.Mktuple3@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> ('a * 'b) * 'c
(declare-fun Tm_arrow_1bedda193f13e939931cf5d46ad84216 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1bedda193f13e939931cf5d46ad84216
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1bedda193f13e939931cf5d46ad84216
Tm_type)
:named kinding_Tm_arrow_1bedda193f13e939931cf5d46ad84216))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1bedda193f13e939931cf5d46ad84216)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1bedda193f13e939931cf5d46ad84216))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1bedda193f13e939931cf5d46ad84216))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1bedda193f13e939931cf5d46ad84216))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1bedda193f13e939931cf5d46ad84216)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
@x1)
(HasType @x5
@x2)
(HasType @x6
@x3))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,66-65,81)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
@x1)
(HasType @x5
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1bedda193f13e939931cf5d46ad84216))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1bedda193f13e939931cf5d46ad84216))

; <Start encoding FStar.Pervasives.Native.tuple3>


; <start constructor FStar.Pervasives.Native.tuple3>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 146
(Term_constr_id (FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)))
 

:pattern ((FStar.Pervasives.Native.tuple3 @x0
@x1
@x2))
:qid constructor_distinct_FStar.Pervasives.Native.tuple3))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple3))))

; </end constructor FStar.Pervasives.Native.tuple3>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (= 147
(Term_constr_id FStar.Pervasives.Native.tuple3@tok))
:named fresh_token_FStar.Pervasives.Native.tuple3@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple3@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Native.tuple3 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple3@tok
@x0)
@x1)
@x2))

:pattern ((FStar.Pervasives.Native.tuple3 @x0
@x1
@x2))
:qid token_correspondence_FStar.Pervasives.Native.tuple3@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple3@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple3@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple3@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple3@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple3@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple3@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple3@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple3@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple3@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple3@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(HasType (FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple3 @x0
@x1
@x2))
:qid kinding_FStar.Pervasives.Native.tuple3@tok.2))
)
:named kinding_FStar.Pervasives.Native.tuple3@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple3 @x2
@x3
@x4))
(= (FStar.Pervasives.Native.tuple3 @x2
@x3
@x4)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple3 @x2
@x3
@x4)))
:qid FStar.Pervasives.Native_pretyping_3c3cf72e1bf7b1d6f8b0873a4feb6ec5))

:named FStar.Pervasives.Native_pretyping_3c3cf72e1bf7b1d6f8b0873a4feb6ec5))

; </end encoding FStar.Pervasives.Native.tuple3>


; <Start encoding FStar.Pervasives.Native.Mktuple3>


; <start constructor FStar.Pervasives.Native.Mktuple3>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= 153
(Term_constr_id (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5)))
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple3))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.Mktuple3__a (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple3__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple3__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.Mktuple3__b (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple3__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple3__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.Mktuple3__c (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple3__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple3__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.Mktuple3__1 (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple3__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple3__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.Mktuple3__2 (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple3__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple3__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.Mktuple3__3 (FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple3__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple3__3))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (= 156
(Term_constr_id FStar.Pervasives.Native.Mktuple3@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple3@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple3@tok
Tm_arrow_1bedda193f13e939931cf5d46ad84216))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple3@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple3@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple3@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple3@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.Mktuple3 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid equality_tok_FStar.Pervasives.Native.Mktuple3@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple3@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
@x1)
(HasTypeFuel @u0
@x5
@x2)
(HasTypeFuel @u0
@x6
@x3))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple3@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple3@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.tuple3 @x7
@x8
@x9))
(and (HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x6
@x9)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x5
@x8)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x4
@x7)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
@x1)
(HasTypeFuel @u0
@x5
@x2)
(HasTypeFuel @u0
@x6
@x3)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.tuple3 @x7
@x8
@x9)))
:qid data_elim_FStar.Pervasives.Native.Mktuple3))

:named data_elim_FStar.Pervasives.Native.Mktuple3))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.tuple3 @x7
@x8
@x9))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x4
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x5
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x6
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.tuple3 @x7
@x8
@x9)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple3))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple3))

; </end encoding FStar.Pervasives.Native.Mktuple3>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,5-65,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple3 @x2
@x3
@x4))
(and (is-FStar.Pervasives.Native.Mktuple3 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple3__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple3__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple3__c @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple3 @x2
@x3
@x4)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple3))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple3))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple3__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple3__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple3__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple3 @x0
@x1
@x2))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)))
:qid assumption_FStar.Pervasives.Native.tuple3__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple3__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple3>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple3 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (('a * 'b) * 'c) -> Prims.bool
(declare-fun Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7
Tm_type)
:named kinding_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7.4))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple3@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.uu___is_Mktuple3 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple3@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple3))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple3@tok
Tm_arrow_f03c6dc5b30146aaca49ed4bf6f332a7))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple3@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.uu___is_Mktuple3 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple3 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple3@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple3))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple3 @x0
@x1
@x2
@x3)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple3 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple3))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple3))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,25-65,33)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple3 @x0
@x1
@x2
@x3)
(BoxBool (is-FStar.Pervasives.Native.Mktuple3 @x3)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple3 @x0
@x1
@x2
@x3))
:qid disc_equation_FStar.Pervasives.Native.Mktuple3))

:named disc_equation_FStar.Pervasives.Native.Mktuple3))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple3>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple3/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple3__item___1>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___1 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (('a * 'b) * 'c) -> 'a
(declare-fun Tm_arrow_592c45439d32a71e1933eacb9776c9ed () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_592c45439d32a71e1933eacb9776c9ed
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_592c45439d32a71e1933eacb9776c9ed
Tm_type)
:named kinding_Tm_arrow_592c45439d32a71e1933eacb9776c9ed))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_592c45439d32a71e1933eacb9776c9ed)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_592c45439d32a71e1933eacb9776c9ed))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_592c45439d32a71e1933eacb9776c9ed))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_592c45439d32a71e1933eacb9776c9ed))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_592c45439d32a71e1933eacb9776c9ed)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,12-65,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_592c45439d32a71e1933eacb9776c9ed))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_592c45439d32a71e1933eacb9776c9ed))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple3__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple3__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok
Tm_arrow_592c45439d32a71e1933eacb9776c9ed))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple3__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x0
@x1
@x2
@x3)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple3__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple3__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,36-65,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x0
@x1
@x2
@x3)
(FStar.Pervasives.Native.Mktuple3__1 @x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___1 @x0
@x1
@x2
@x3))
:qid proj_equation_FStar.Pervasives.Native.Mktuple3__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple3__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple3__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple3__item___1/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple3__item___2>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___2 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (('a * 'b) * 'c) -> 'b
(declare-fun Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab
Tm_type)
:named kinding_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,15-65,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple3__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple3__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok
Tm_arrow_9c9b0c5ac9b0fbfc367f406af296ecab))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple3__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x0
@x1
@x2
@x3)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple3__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple3__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,46-65,48)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x0
@x1
@x2
@x3)
(FStar.Pervasives.Native.Mktuple3__2 @x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___2 @x0
@x1
@x2
@x3))
:qid proj_equation_FStar.Pervasives.Native.Mktuple3__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple3__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple3__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple3__item___2/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple3__item___3>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___3 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (('a * 'b) * 'c) -> 'c
(declare-fun Tm_arrow_08246a62c9aeca08c44c602ad80e95a4 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_08246a62c9aeca08c44c602ad80e95a4
Tm_type)
:named kinding_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_08246a62c9aeca08c44c602ad80e95a4)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_08246a62c9aeca08c44c602ad80e95a4)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,18-65,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple3__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple3__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok
Tm_arrow_08246a62c9aeca08c44c602ad80e95a4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple3__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple3__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.Native.tuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x0
@x1
@x2
@x3)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple3__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple3__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple3__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(65,56-65,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x0
@x1
@x2
@x3)
(FStar.Pervasives.Native.Mktuple3__3 @x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple3__item___3 @x0
@x1
@x2
@x3))
:qid proj_equation_FStar.Pervasives.Native.Mktuple3__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple3__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple3__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple3__item___3/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple4 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple4@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple4@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple4@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple4@x3 (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: Mktuple4
(declare-fun FStar.Pervasives.Native.Mktuple4@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> (('a * 'b) * 'c) * 'd
(declare-fun Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f
Tm_type)
:named kinding_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
@x1)
(HasType @x6
@x2)
(HasType @x7
@x3)
(HasType @x8
@x4))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
@x1)
(HasType @x6
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,79-67,97)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
@x1)
(HasType @x6
@x2)
(HasType @x7
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))

; <Start encoding FStar.Pervasives.Native.tuple4>


; <start constructor FStar.Pervasives.Native.tuple4>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= 165
(Term_constr_id (FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
 

:pattern ((FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3))
:qid constructor_distinct_FStar.Pervasives.Native.tuple4))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple4))))

; </end constructor FStar.Pervasives.Native.tuple4>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (= 166
(Term_constr_id FStar.Pervasives.Native.tuple4@tok))
:named fresh_token_FStar.Pervasives.Native.tuple4@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0)
@x1)
@x2)
@x3))

:pattern ((FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3))
:qid token_correspondence_FStar.Pervasives.Native.tuple4@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple4@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple4@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple4@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple4@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple4@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple4@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple4@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple4@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(HasType (FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3))
:qid kinding_FStar.Pervasives.Native.tuple4@tok.3))
)
:named kinding_FStar.Pervasives.Native.tuple4@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple4 @x2
@x3
@x4
@x5))
(= (FStar.Pervasives.Native.tuple4 @x2
@x3
@x4
@x5)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple4 @x2
@x3
@x4
@x5)))
:qid FStar.Pervasives.Native_pretyping_a921c31b95ad6298eaccfc3532fde0e3))

:named FStar.Pervasives.Native_pretyping_a921c31b95ad6298eaccfc3532fde0e3))

; </end encoding FStar.Pervasives.Native.tuple4>


; <Start encoding FStar.Pervasives.Native.Mktuple4>


; <start constructor FStar.Pervasives.Native.Mktuple4>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= 172
(Term_constr_id (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple4))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__a (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__b (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__c (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__d (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__1 (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__2 (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__3 (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.Mktuple4__4 (FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple4__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple4__4))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (= 175
(Term_constr_id FStar.Pervasives.Native.Mktuple4@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple4@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple4@tok
Tm_arrow_cbe72a10167439fe1ecfaf4fec8fd23f))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple4@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple4@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple4@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple4@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.Mktuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid equality_tok_FStar.Pervasives.Native.Mktuple4@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple4@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
@x1)
(HasTypeFuel @u0
@x6
@x2)
(HasTypeFuel @u0
@x7
@x3)
(HasTypeFuel @u0
@x8
@x4))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple4@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple4@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.tuple4 @x9
@x10
@x11
@x12))
(and (HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x8
@x12)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x7
@x11)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x6
@x10)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x5
@x9)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
@x1)
(HasTypeFuel @u0
@x6
@x2)
(HasTypeFuel @u0
@x7
@x3)
(HasTypeFuel @u0
@x8
@x4)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.tuple4 @x9
@x10
@x11
@x12)))
:qid data_elim_FStar.Pervasives.Native.Mktuple4))

:named data_elim_FStar.Pervasives.Native.Mktuple4))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.tuple4 @x9
@x10
@x11
@x12))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x5
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x6
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x7
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x8
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.tuple4 @x9
@x10
@x11
@x12)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple4))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple4))

; </end encoding FStar.Pervasives.Native.Mktuple4>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,5-67,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple4 @x2
@x3
@x4
@x5))
(and (is-FStar.Pervasives.Native.Mktuple4 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple4__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple4__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple4__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple4__d @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple4 @x2
@x3
@x4
@x5)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple4))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple4))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple4__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple4__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple4__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
:qid assumption_FStar.Pervasives.Native.tuple4__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple4__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple4>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple4 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((('a * 'b) * 'c) * 'd) -> Prims.bool
(declare-fun Tm_arrow_4319694c225efa92ce9fad6e9d81f761 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4319694c225efa92ce9fad6e9d81f761
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_4319694c225efa92ce9fad6e9d81f761
Tm_type)
:named kinding_Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_4319694c225efa92ce9fad6e9d81f761)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_4319694c225efa92ce9fad6e9d81f761)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761.5))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_4319694c225efa92ce9fad6e9d81f761))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.uu___is_Mktuple4 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple4))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple4@tok
Tm_arrow_4319694c225efa92ce9fad6e9d81f761))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.uu___is_Mktuple4 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple4 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple4@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple4))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple4 @x0
@x1
@x2
@x3
@x4)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple4 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple4))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple4))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,28-67,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple4 @x0
@x1
@x2
@x3
@x4)
(BoxBool (is-FStar.Pervasives.Native.Mktuple4 @x4)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple4 @x0
@x1
@x2
@x3
@x4))
:qid disc_equation_FStar.Pervasives.Native.Mktuple4))

:named disc_equation_FStar.Pervasives.Native.Mktuple4))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple4>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple4/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple4__item___1>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___1 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((('a * 'b) * 'c) * 'd) -> 'a
(declare-fun Tm_arrow_382d1e9129053162252ec57e86d46f82 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_382d1e9129053162252ec57e86d46f82
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_382d1e9129053162252ec57e86d46f82
Tm_type)
:named kinding_Tm_arrow_382d1e9129053162252ec57e86d46f82))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_382d1e9129053162252ec57e86d46f82)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_382d1e9129053162252ec57e86d46f82))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_382d1e9129053162252ec57e86d46f82))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_382d1e9129053162252ec57e86d46f82))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_382d1e9129053162252ec57e86d46f82)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,12-67,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_382d1e9129053162252ec57e86d46f82))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_382d1e9129053162252ec57e86d46f82))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok
Tm_arrow_382d1e9129053162252ec57e86d46f82))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple4__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x0
@x1
@x2
@x3
@x4)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple4__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple4__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,39-67,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.Mktuple4__1 @x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___1 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Native.Mktuple4__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple4__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple4__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple4__item___1/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple4__item___2>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___2 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((('a * 'b) * 'c) * 'd) -> 'b
(declare-fun Tm_arrow_fffd25e5325d259efa0675ef649c6864 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_fffd25e5325d259efa0675ef649c6864
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_fffd25e5325d259efa0675ef649c6864
Tm_type)
:named kinding_Tm_arrow_fffd25e5325d259efa0675ef649c6864))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_fffd25e5325d259efa0675ef649c6864)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_fffd25e5325d259efa0675ef649c6864))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_fffd25e5325d259efa0675ef649c6864))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_fffd25e5325d259efa0675ef649c6864))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_fffd25e5325d259efa0675ef649c6864)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,15-67,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_fffd25e5325d259efa0675ef649c6864))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_fffd25e5325d259efa0675ef649c6864))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok
Tm_arrow_fffd25e5325d259efa0675ef649c6864))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple4__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x0
@x1
@x2
@x3
@x4)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple4__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple4__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,49-67,51)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.Mktuple4__2 @x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___2 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Native.Mktuple4__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple4__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple4__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple4__item___2/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple4__item___3>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___3 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((('a * 'b) * 'c) * 'd) -> 'c
(declare-fun Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2
Tm_type)
:named kinding_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,18-67,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok
Tm_arrow_57b4005e0833f7b396e349ed7cdd1bb2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple4__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x0
@x1
@x2
@x3
@x4)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple4__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple4__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,59-67,61)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.Mktuple4__3 @x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___3 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Native.Mktuple4__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple4__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple4__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple4__item___3/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple4__item___4>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___4 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((('a * 'b) * 'c) * 'd) -> 'd
(declare-fun Tm_arrow_9e6c1a63d63f8735645b9898955a2dca () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9e6c1a63d63f8735645b9898955a2dca
Tm_type)
:named kinding_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9e6c1a63d63f8735645b9898955a2dca)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9e6c1a63d63f8735645b9898955a2dca)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,21-67,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple4__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok
Tm_arrow_9e6c1a63d63f8735645b9898955a2dca))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple4__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple4__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.Native.tuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x0
@x1
@x2
@x3
@x4)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple4__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple4__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple4__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(67,69-67,71)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Native.Mktuple4__4 @x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple4__item___4 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Native.Mktuple4__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple4__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple4__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple4__item___4/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple5 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple5@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple5@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple5@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple5@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple5@x4 (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: Mktuple5
(declare-fun FStar.Pervasives.Native.Mktuple5@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> ((('a * 'b) * 'c) * 'd) * 'e
(declare-fun Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887
Tm_type)
:named kinding_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
@x1)
(HasType @x7
@x2)
(HasType @x8
@x3)
(HasType @x9
@x4)
(HasType @x10
@x5))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
@x1)
(HasType @x7
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
@x1)
(HasType @x7
@x2)
(HasType @x8
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,65-70,86)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
@x1)
(HasType @x7
@x2)
(HasType @x8
@x3)
(HasType @x9
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))

; <Start encoding FStar.Pervasives.Native.tuple5>


; <start constructor FStar.Pervasives.Native.tuple5>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= 186
(Term_constr_id (FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
 

:pattern ((FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4))
:qid constructor_distinct_FStar.Pervasives.Native.tuple5))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple5))))

; </end constructor FStar.Pervasives.Native.tuple5>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (= 187
(Term_constr_id FStar.Pervasives.Native.tuple5@tok))
:named fresh_token_FStar.Pervasives.Native.tuple5@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1)
@x2)
@x3)
@x4))

:pattern ((FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4))
:qid token_correspondence_FStar.Pervasives.Native.tuple5@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple5@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple5@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple5@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple5@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple5@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple5@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple5@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple5@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple5@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(HasType (FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4))
:qid kinding_FStar.Pervasives.Native.tuple5@tok.4))
)
:named kinding_FStar.Pervasives.Native.tuple5@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple5 @x2
@x3
@x4
@x5
@x6))
(= (FStar.Pervasives.Native.tuple5 @x2
@x3
@x4
@x5
@x6)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple5 @x2
@x3
@x4
@x5
@x6)))
:qid FStar.Pervasives.Native_pretyping_616a6997592eb0970d9b3cb7e154d4a2))

:named FStar.Pervasives.Native_pretyping_616a6997592eb0970d9b3cb7e154d4a2))

; </end encoding FStar.Pervasives.Native.tuple5>


; <Start encoding FStar.Pervasives.Native.Mktuple5>


; <start constructor FStar.Pervasives.Native.Mktuple5>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= 193
(Term_constr_id (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple5))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__a (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__b (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__c (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__d (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__e (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__1 (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__2 (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__3 (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__4 (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.Mktuple5__5 (FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple5__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple5__5))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (= 196
(Term_constr_id FStar.Pervasives.Native.Mktuple5@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple5@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple5@tok
Tm_arrow_dd8a078a1b97a81b5089dc3637cc2887))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple5@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple5@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple5@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple5@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid equality_tok_FStar.Pervasives.Native.Mktuple5@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple5@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
@x1)
(HasTypeFuel @u0
@x7
@x2)
(HasTypeFuel @u0
@x8
@x3)
(HasTypeFuel @u0
@x9
@x4)
(HasTypeFuel @u0
@x10
@x5))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple5@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple5@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.tuple5 @x11
@x12
@x13
@x14
@x15))
(and (HasTypeFuel @u0
@x15
Tm_type)
(HasTypeFuel @u0
@x10
@x15)
(HasTypeFuel @u0
@x14
Tm_type)
(HasTypeFuel @u0
@x9
@x14)
(HasTypeFuel @u0
@x13
Tm_type)
(HasTypeFuel @u0
@x8
@x13)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x7
@x12)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x6
@x11)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
@x1)
(HasTypeFuel @u0
@x7
@x2)
(HasTypeFuel @u0
@x8
@x3)
(HasTypeFuel @u0
@x9
@x4)
(HasTypeFuel @u0
@x10
@x5)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.tuple5 @x11
@x12
@x13
@x14
@x15)))
:qid data_elim_FStar.Pervasives.Native.Mktuple5))

:named data_elim_FStar.Pervasives.Native.Mktuple5))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.tuple5 @x11
@x12
@x13
@x14
@x15))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x6
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x7
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x8
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x9
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x10
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.tuple5 @x11
@x12
@x13
@x14
@x15)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple5))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple5))

; </end encoding FStar.Pervasives.Native.Mktuple5>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,5-69,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple5 @x2
@x3
@x4
@x5
@x6))
(and (is-FStar.Pervasives.Native.Mktuple5 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple5__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple5__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple5__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple5__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple5__e @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple5 @x2
@x3
@x4
@x5
@x6)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple5))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple5))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple5__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple5__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple5__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
:qid assumption_FStar.Pervasives.Native.tuple5__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple5__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple5>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple5 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((('a * 'b) * 'c) * 'd) * 'e) -> Prims.bool
(declare-fun Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9
Tm_type)
:named kinding_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9.6))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.uu___is_Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple5))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple5@tok
Tm_arrow_cfa2e2c8b8b41312889ff659c4faa5f9))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.uu___is_Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple5 @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple5@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple5))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple5))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple5))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,4-70,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5)
(BoxBool (is-FStar.Pervasives.Native.Mktuple5 @x5)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple5 @x0
@x1
@x2
@x3
@x4
@x5))
:qid disc_equation_FStar.Pervasives.Native.Mktuple5))

:named disc_equation_FStar.Pervasives.Native.Mktuple5))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple5>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple5/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple5__item___1>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___1 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((('a * 'b) * 'c) * 'd) * 'e) -> 'a
(declare-fun Tm_arrow_7519f72fe101267af170e00c6ce694af () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7519f72fe101267af170e00c6ce694af
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7519f72fe101267af170e00c6ce694af
Tm_type)
:named kinding_Tm_arrow_7519f72fe101267af170e00c6ce694af))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7519f72fe101267af170e00c6ce694af)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7519f72fe101267af170e00c6ce694af))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7519f72fe101267af170e00c6ce694af))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7519f72fe101267af170e00c6ce694af))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7519f72fe101267af170e00c6ce694af)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,12-69,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7519f72fe101267af170e00c6ce694af))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7519f72fe101267af170e00c6ce694af))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok
Tm_arrow_7519f72fe101267af170e00c6ce694af))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple5__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x0
@x1
@x2
@x3
@x4
@x5)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple5__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple5__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,15-70,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x0
@x1
@x2
@x3
@x4
@x5)
(FStar.Pervasives.Native.Mktuple5__1 @x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___1 @x0
@x1
@x2
@x3
@x4
@x5))
:qid proj_equation_FStar.Pervasives.Native.Mktuple5__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple5__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple5__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple5__item___1/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple5__item___2>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___2 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((('a * 'b) * 'c) * 'd) * 'e) -> 'b
(declare-fun Tm_arrow_3e46329f224aa70981a337f98afbaa87 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3e46329f224aa70981a337f98afbaa87
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3e46329f224aa70981a337f98afbaa87
Tm_type)
:named kinding_Tm_arrow_3e46329f224aa70981a337f98afbaa87))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3e46329f224aa70981a337f98afbaa87)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3e46329f224aa70981a337f98afbaa87))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3e46329f224aa70981a337f98afbaa87))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3e46329f224aa70981a337f98afbaa87))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3e46329f224aa70981a337f98afbaa87)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,15-69,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3e46329f224aa70981a337f98afbaa87))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3e46329f224aa70981a337f98afbaa87))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok
Tm_arrow_3e46329f224aa70981a337f98afbaa87))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple5__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x0
@x1
@x2
@x3
@x4
@x5)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple5__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple5__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,25-70,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x0
@x1
@x2
@x3
@x4
@x5)
(FStar.Pervasives.Native.Mktuple5__2 @x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___2 @x0
@x1
@x2
@x3
@x4
@x5))
:qid proj_equation_FStar.Pervasives.Native.Mktuple5__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple5__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple5__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple5__item___2/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple5__item___3>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___3 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((('a * 'b) * 'c) * 'd) * 'e) -> 'c
(declare-fun Tm_arrow_55e6dc1b736536de45fedf844003f847 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_55e6dc1b736536de45fedf844003f847
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_55e6dc1b736536de45fedf844003f847
Tm_type)
:named kinding_Tm_arrow_55e6dc1b736536de45fedf844003f847))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_55e6dc1b736536de45fedf844003f847)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_55e6dc1b736536de45fedf844003f847))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_55e6dc1b736536de45fedf844003f847))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_55e6dc1b736536de45fedf844003f847))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_55e6dc1b736536de45fedf844003f847)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,18-69,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_55e6dc1b736536de45fedf844003f847))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_55e6dc1b736536de45fedf844003f847))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok
Tm_arrow_55e6dc1b736536de45fedf844003f847))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple5__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x0
@x1
@x2
@x3
@x4
@x5)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple5__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple5__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,35-70,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x0
@x1
@x2
@x3
@x4
@x5)
(FStar.Pervasives.Native.Mktuple5__3 @x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid proj_equation_FStar.Pervasives.Native.Mktuple5__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple5__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple5__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple5__item___3/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple5__item___4>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___4 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((('a * 'b) * 'c) * 'd) * 'e) -> 'd
(declare-fun Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398
Tm_type)
:named kinding_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,21-69,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok
Tm_arrow_3a4e86c6aee1a39b4811bdbc12405398))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple5__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x0
@x1
@x2
@x3
@x4
@x5)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple5__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple5__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,45-70,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x0
@x1
@x2
@x3
@x4
@x5)
(FStar.Pervasives.Native.Mktuple5__4 @x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___4 @x0
@x1
@x2
@x3
@x4
@x5))
:qid proj_equation_FStar.Pervasives.Native.Mktuple5__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple5__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple5__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple5__item___4/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple5__item___5>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___5 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((('a * 'b) * 'c) * 'd) * 'e) -> 'e
(declare-fun Tm_arrow_1a78355922fdaba3f3848932dfc0a089 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1a78355922fdaba3f3848932dfc0a089
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1a78355922fdaba3f3848932dfc0a089
Tm_type)
:named kinding_Tm_arrow_1a78355922fdaba3f3848932dfc0a089))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1a78355922fdaba3f3848932dfc0a089)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1a78355922fdaba3f3848932dfc0a089))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1a78355922fdaba3f3848932dfc0a089))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1a78355922fdaba3f3848932dfc0a089))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1a78355922fdaba3f3848932dfc0a089)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple5 @x1
@x2
@x3
@x4
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(69,24-69,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1a78355922fdaba3f3848932dfc0a089))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1a78355922fdaba3f3848932dfc0a089))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple5__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok
Tm_arrow_1a78355922fdaba3f3848932dfc0a089))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple5__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple5__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
(FStar.Pervasives.Native.tuple5 @x0
@x1
@x2
@x3
@x4)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x0
@x1
@x2
@x3
@x4
@x5)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple5__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple5__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple5__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(70,55-70,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x0
@x1
@x2
@x3
@x4
@x5)
(FStar.Pervasives.Native.Mktuple5__5 @x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple5__item___5 @x0
@x1
@x2
@x3
@x4
@x5))
:qid proj_equation_FStar.Pervasives.Native.Mktuple5__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple5__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple5__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple5__item___5/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple6 (Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple6@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple6@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple6@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple6@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple6@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple6@x5 (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: Mktuple6
(declare-fun FStar.Pervasives.Native.Mktuple6@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> (((('a * 'b) * 'c) * 'd) * 'e) * 'f
(declare-fun Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67
Tm_type)
:named kinding_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
@x1)
(HasType @x8
@x2)
(HasType @x9
@x3)
(HasType @x10
@x4)
(HasType @x11
@x5)
(HasType @x12
@x6))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
@x1)
(HasType @x8
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
@x1)
(HasType @x8
@x2)
(HasType @x9
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
@x1)
(HasType @x8
@x2)
(HasType @x9
@x3)
(HasType @x10
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,75-73,99)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
@x1)
(HasType @x8
@x2)
(HasType @x9
@x3)
(HasType @x10
@x4)
(HasType @x11
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))

; <Start encoding FStar.Pervasives.Native.tuple6>


; <start constructor FStar.Pervasives.Native.tuple6>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= 209
(Term_constr_id (FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
 

:pattern ((FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5))
:qid constructor_distinct_FStar.Pervasives.Native.tuple6))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple6))))

; </end constructor FStar.Pervasives.Native.tuple6>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (= 210
(Term_constr_id FStar.Pervasives.Native.tuple6@tok))
:named fresh_token_FStar.Pervasives.Native.tuple6@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))

:pattern ((FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5))
:qid token_correspondence_FStar.Pervasives.Native.tuple6@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple6@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple6@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple6@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple6@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple6@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple6@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple6@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple6@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple6@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(HasType (FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5))
:qid kinding_FStar.Pervasives.Native.tuple6@tok.5))
)
:named kinding_FStar.Pervasives.Native.tuple6@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple6 @x2
@x3
@x4
@x5
@x6
@x7))
(= (FStar.Pervasives.Native.tuple6 @x2
@x3
@x4
@x5
@x6
@x7)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple6 @x2
@x3
@x4
@x5
@x6
@x7)))
:qid FStar.Pervasives.Native_pretyping_77f71cd45f062f25ddde8ee758ebe7ca))

:named FStar.Pervasives.Native_pretyping_77f71cd45f062f25ddde8ee758ebe7ca))

; </end encoding FStar.Pervasives.Native.tuple6>


; <Start encoding FStar.Pervasives.Native.Mktuple6>


; <start constructor FStar.Pervasives.Native.Mktuple6>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= 216
(Term_constr_id (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple6))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__a (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__b (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__c (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__d (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__e (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__f (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__1 (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__2 (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__3 (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__4 (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__5 (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.Mktuple6__6 (FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple6__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple6__6))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (= 219
(Term_constr_id FStar.Pervasives.Native.Mktuple6@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple6@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple6@tok
Tm_arrow_f277ffaa7e891207f9c6bff5b88ffd67))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple6@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple6@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple6@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple6@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid equality_tok_FStar.Pervasives.Native.Mktuple6@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple6@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
@x1)
(HasTypeFuel @u0
@x8
@x2)
(HasTypeFuel @u0
@x9
@x3)
(HasTypeFuel @u0
@x10
@x4)
(HasTypeFuel @u0
@x11
@x5)
(HasTypeFuel @u0
@x12
@x6))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple6@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple6@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.tuple6 @x13
@x14
@x15
@x16
@x17
@x18))
(and (HasTypeFuel @u0
@x18
Tm_type)
(HasTypeFuel @u0
@x12
@x18)
(HasTypeFuel @u0
@x17
Tm_type)
(HasTypeFuel @u0
@x11
@x17)
(HasTypeFuel @u0
@x16
Tm_type)
(HasTypeFuel @u0
@x10
@x16)
(HasTypeFuel @u0
@x15
Tm_type)
(HasTypeFuel @u0
@x9
@x15)
(HasTypeFuel @u0
@x14
Tm_type)
(HasTypeFuel @u0
@x8
@x14)
(HasTypeFuel @u0
@x13
Tm_type)
(HasTypeFuel @u0
@x7
@x13)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
@x1)
(HasTypeFuel @u0
@x8
@x2)
(HasTypeFuel @u0
@x9
@x3)
(HasTypeFuel @u0
@x10
@x4)
(HasTypeFuel @u0
@x11
@x5)
(HasTypeFuel @u0
@x12
@x6)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.tuple6 @x13
@x14
@x15
@x16
@x17
@x18)))
:qid data_elim_FStar.Pervasives.Native.Mktuple6))

:named data_elim_FStar.Pervasives.Native.Mktuple6))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.tuple6 @x13
@x14
@x15
@x16
@x17
@x18))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x7
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x8
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x9
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x10
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x11
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x12
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.tuple6 @x13
@x14
@x15
@x16
@x17
@x18)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple6))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple6))

; </end encoding FStar.Pervasives.Native.Mktuple6>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,5-72,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple6 @x2
@x3
@x4
@x5
@x6
@x7))
(and (is-FStar.Pervasives.Native.Mktuple6 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple6__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple6__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple6__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple6__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple6__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple6__f @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple6 @x2
@x3
@x4
@x5
@x6
@x7)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple6))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple6))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple6__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple6__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple6__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
:qid assumption_FStar.Pervasives.Native.tuple6__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple6__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple6>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple6 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> Prims.bool
(declare-fun Tm_arrow_286587a1b9d299ba75a076f54a6dad5f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_286587a1b9d299ba75a076f54a6dad5f
Tm_type)
:named kinding_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_286587a1b9d299ba75a076f54a6dad5f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_286587a1b9d299ba75a076f54a6dad5f)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f.7))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.uu___is_Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple6))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple6@tok
Tm_arrow_286587a1b9d299ba75a076f54a6dad5f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.uu___is_Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple6 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple6@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple6))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple6))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple6))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,4-73,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(BoxBool (is-FStar.Pervasives.Native.Mktuple6 @x6)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple6 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid disc_equation_FStar.Pervasives.Native.Mktuple6))

:named disc_equation_FStar.Pervasives.Native.Mktuple6))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple6>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple6/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple6__item___1>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___1 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> 'a
(declare-fun Tm_arrow_5b1e145eeceab869b8e427e6927dbd63 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_5b1e145eeceab869b8e427e6927dbd63
Tm_type)
:named kinding_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5b1e145eeceab869b8e427e6927dbd63)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5b1e145eeceab869b8e427e6927dbd63)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,12-72,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok
Tm_arrow_5b1e145eeceab869b8e427e6927dbd63))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple6__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple6__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple6__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,15-73,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.Mktuple6__1 @x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid proj_equation_FStar.Pervasives.Native.Mktuple6__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple6__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple6__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple6__item___1/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple6__item___2>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___2 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> 'b
(declare-fun Tm_arrow_3207475e225d584881d3e0a297482887 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3207475e225d584881d3e0a297482887
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3207475e225d584881d3e0a297482887
Tm_type)
:named kinding_Tm_arrow_3207475e225d584881d3e0a297482887))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3207475e225d584881d3e0a297482887)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3207475e225d584881d3e0a297482887))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3207475e225d584881d3e0a297482887))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3207475e225d584881d3e0a297482887))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3207475e225d584881d3e0a297482887
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3207475e225d584881d3e0a297482887)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,15-72,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3207475e225d584881d3e0a297482887))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3207475e225d584881d3e0a297482887))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok
Tm_arrow_3207475e225d584881d3e0a297482887))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple6__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple6__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple6__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,25-73,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.Mktuple6__2 @x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid proj_equation_FStar.Pervasives.Native.Mktuple6__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple6__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple6__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple6__item___2/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple6__item___3>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___3 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> 'c
(declare-fun Tm_arrow_43e491b3b537a523a4f10de18b1915f5 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_43e491b3b537a523a4f10de18b1915f5
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_43e491b3b537a523a4f10de18b1915f5
Tm_type)
:named kinding_Tm_arrow_43e491b3b537a523a4f10de18b1915f5))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_43e491b3b537a523a4f10de18b1915f5)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_43e491b3b537a523a4f10de18b1915f5))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_43e491b3b537a523a4f10de18b1915f5))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_43e491b3b537a523a4f10de18b1915f5))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_43e491b3b537a523a4f10de18b1915f5)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,18-72,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_43e491b3b537a523a4f10de18b1915f5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_43e491b3b537a523a4f10de18b1915f5))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok
Tm_arrow_43e491b3b537a523a4f10de18b1915f5))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple6__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple6__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple6__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,35-73,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.Mktuple6__3 @x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid proj_equation_FStar.Pervasives.Native.Mktuple6__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple6__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple6__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple6__item___3/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple6__item___4>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___4 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> 'd
(declare-fun Tm_arrow_f5747d5b721642d7ecb757b043f20880 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f5747d5b721642d7ecb757b043f20880
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f5747d5b721642d7ecb757b043f20880
Tm_type)
:named kinding_Tm_arrow_f5747d5b721642d7ecb757b043f20880))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f5747d5b721642d7ecb757b043f20880)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f5747d5b721642d7ecb757b043f20880))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f5747d5b721642d7ecb757b043f20880))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f5747d5b721642d7ecb757b043f20880))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f5747d5b721642d7ecb757b043f20880)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,21-72,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f5747d5b721642d7ecb757b043f20880))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_f5747d5b721642d7ecb757b043f20880))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok
Tm_arrow_f5747d5b721642d7ecb757b043f20880))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple6__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple6__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple6__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,45-73,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.Mktuple6__4 @x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid proj_equation_FStar.Pervasives.Native.Mktuple6__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple6__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple6__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple6__item___4/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple6__item___5>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___5 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> 'e
(declare-fun Tm_arrow_d6501381a0206e157ecc43950bb31fea () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_d6501381a0206e157ecc43950bb31fea
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_d6501381a0206e157ecc43950bb31fea
Tm_type)
:named kinding_Tm_arrow_d6501381a0206e157ecc43950bb31fea))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_d6501381a0206e157ecc43950bb31fea)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_d6501381a0206e157ecc43950bb31fea))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_d6501381a0206e157ecc43950bb31fea))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_d6501381a0206e157ecc43950bb31fea))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_d6501381a0206e157ecc43950bb31fea)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,24-72,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_d6501381a0206e157ecc43950bb31fea))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_d6501381a0206e157ecc43950bb31fea))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok
Tm_arrow_d6501381a0206e157ecc43950bb31fea))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple6__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple6__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple6__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,55-73,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.Mktuple6__5 @x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid proj_equation_FStar.Pervasives.Native.Mktuple6__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple6__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple6__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple6__item___5/>


; <Start encoding FStar.Pervasives.Native.__proj__Mktuple6__item___6>

(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___6 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) -> 'f
(declare-fun Tm_arrow_9c342f41120d0c7aea115b09b58cefb2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9c342f41120d0c7aea115b09b58cefb2
Tm_type)
:named kinding_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9c342f41120d0c7aea115b09b58cefb2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9c342f41120d0c7aea115b09b58cefb2)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple6 @x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(72,27-72,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple6__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok
Tm_arrow_9c342f41120d0c7aea115b09b58cefb2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple6__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple6__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
(FStar.Pervasives.Native.tuple6 @x0
@x1
@x2
@x3
@x4
@x5)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple6__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple6__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple6__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(73,65-73,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.Native.Mktuple6__6 @x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple6__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid proj_equation_FStar.Pervasives.Native.Mktuple6__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple6__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple6__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple6__item___6/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple7 (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple7@x6 (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: Mktuple7
(declare-fun FStar.Pervasives.Native.Mktuple7@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> _7: 'g   -> ((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g
(declare-fun Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230
Tm_type)
:named kinding_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1)
(HasType @x9
@x2)
(HasType @x10
@x3)
(HasType @x11
@x4)
(HasType @x12
@x5)
(HasType @x13
@x6)
(HasType @x14
@x7))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1)
(HasType @x9
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1)
(HasType @x9
@x2)
(HasType @x10
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1)
(HasType @x9
@x2)
(HasType @x10
@x3)
(HasType @x11
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1)
(HasType @x9
@x2)
(HasType @x10
@x3)
(HasType @x11
@x4)
(HasType @x12
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(77,7-77,34)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
@x1)
(HasType @x9
@x2)
(HasType @x10
@x3)
(HasType @x11
@x4)
(HasType @x12
@x5)
(HasType @x13
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))

; <Start encoding FStar.Pervasives.Native.tuple7>


; <start constructor FStar.Pervasives.Native.tuple7>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= 234
(Term_constr_id (FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
 

:pattern ((FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid constructor_distinct_FStar.Pervasives.Native.tuple7))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple7))))

; </end constructor FStar.Pervasives.Native.tuple7>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (= 235
(Term_constr_id FStar.Pervasives.Native.tuple7@tok))
:named fresh_token_FStar.Pervasives.Native.tuple7@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))

:pattern ((FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid token_correspondence_FStar.Pervasives.Native.tuple7@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple7@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple7@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple7@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple7@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple7@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple7@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple7@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple7@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple7@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple7@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(HasType (FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid kinding_FStar.Pervasives.Native.tuple7@tok.6))
)
:named kinding_FStar.Pervasives.Native.tuple7@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple7 @x2
@x3
@x4
@x5
@x6
@x7
@x8))
(= (FStar.Pervasives.Native.tuple7 @x2
@x3
@x4
@x5
@x6
@x7
@x8)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple7 @x2
@x3
@x4
@x5
@x6
@x7
@x8)))
:qid FStar.Pervasives.Native_pretyping_6b53da96265c34bc84c778bd6410b170))

:named FStar.Pervasives.Native_pretyping_6b53da96265c34bc84c778bd6410b170))

; </end encoding FStar.Pervasives.Native.tuple7>


; <Start encoding FStar.Pervasives.Native.Mktuple7>


; <start constructor FStar.Pervasives.Native.Mktuple7>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= 241
(Term_constr_id (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple7))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__a (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__b (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__c (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__d (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__e (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__f (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__g (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__1 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__2 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__3 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__4 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__5 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__6 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.Mktuple7__7 (FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple7__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple7__7))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (= 244
(Term_constr_id FStar.Pervasives.Native.Mktuple7@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple7@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple7@tok
Tm_arrow_37ee9ec407a0f7bb69bf1b308f74a230))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple7@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple7@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple7@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple7@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid equality_tok_FStar.Pervasives.Native.Mktuple7@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple7@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@u0 Fuel) (@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) (@x14 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
@x1)
(HasTypeFuel @u0
@x9
@x2)
(HasTypeFuel @u0
@x10
@x3)
(HasTypeFuel @u0
@x11
@x4)
(HasTypeFuel @u0
@x12
@x5)
(HasTypeFuel @u0
@x13
@x6)
(HasTypeFuel @u0
@x14
@x7))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple7@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple7@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.tuple7 @x15
@x16
@x17
@x18
@x19
@x20
@x21))
(and (HasTypeFuel @u0
@x21
Tm_type)
(HasTypeFuel @u0
@x14
@x21)
(HasTypeFuel @u0
@x20
Tm_type)
(HasTypeFuel @u0
@x13
@x20)
(HasTypeFuel @u0
@x19
Tm_type)
(HasTypeFuel @u0
@x12
@x19)
(HasTypeFuel @u0
@x18
Tm_type)
(HasTypeFuel @u0
@x11
@x18)
(HasTypeFuel @u0
@x17
Tm_type)
(HasTypeFuel @u0
@x10
@x17)
(HasTypeFuel @u0
@x16
Tm_type)
(HasTypeFuel @u0
@x9
@x16)
(HasTypeFuel @u0
@x15
Tm_type)
(HasTypeFuel @u0
@x8
@x15)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
@x1)
(HasTypeFuel @u0
@x9
@x2)
(HasTypeFuel @u0
@x10
@x3)
(HasTypeFuel @u0
@x11
@x4)
(HasTypeFuel @u0
@x12
@x5)
(HasTypeFuel @u0
@x13
@x6)
(HasTypeFuel @u0
@x14
@x7)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.tuple7 @x15
@x16
@x17
@x18
@x19
@x20
@x21)))
:qid data_elim_FStar.Pervasives.Native.Mktuple7))

:named data_elim_FStar.Pervasives.Native.Mktuple7))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.tuple7 @x15
@x16
@x17
@x18
@x19
@x20
@x21))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x8
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x9
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x10
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x11
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x12
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x13
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.tuple7 @x15
@x16
@x17
@x18
@x19
@x20
@x21)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple7))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple7))

; </end encoding FStar.Pervasives.Native.Mktuple7>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,5-75,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple7 @x2
@x3
@x4
@x5
@x6
@x7
@x8))
(and (is-FStar.Pervasives.Native.Mktuple7 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple7__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple7__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple7__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple7__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple7__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple7__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple7__g @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple7 @x2
@x3
@x4
@x5
@x6
@x7
@x8)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple7))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple7))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple7__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple7__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple7__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
:qid assumption_FStar.Pervasives.Native.tuple7__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple7__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple7>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple7 (Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> Prims.bool
(declare-fun Tm_arrow_612dde2fedb1440c5d790ba7f5015319 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_612dde2fedb1440c5d790ba7f5015319
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_612dde2fedb1440c5d790ba7f5015319
Tm_type)
:named kinding_Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_612dde2fedb1440c5d790ba7f5015319)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_612dde2fedb1440c5d790ba7f5015319)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319.8))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_612dde2fedb1440c5d790ba7f5015319))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.uu___is_Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple7))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple7@tok
Tm_arrow_612dde2fedb1440c5d790ba7f5015319))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.uu___is_Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple7@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple7))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple7))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple7))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,4-76,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(BoxBool (is-FStar.Pervasives.Native.Mktuple7 @x7)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid disc_equation_FStar.Pervasives.Native.Mktuple7))

:named disc_equation_FStar.Pervasives.Native.Mktuple7))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple7>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'a
(declare-fun Tm_arrow_01c4488a68699f466c59799f5c1173ff () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_01c4488a68699f466c59799f5c1173ff
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_01c4488a68699f466c59799f5c1173ff
Tm_type)
:named kinding_Tm_arrow_01c4488a68699f466c59799f5c1173ff))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_01c4488a68699f466c59799f5c1173ff)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_01c4488a68699f466c59799f5c1173ff))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_01c4488a68699f466c59799f5c1173ff))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_01c4488a68699f466c59799f5c1173ff))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_01c4488a68699f466c59799f5c1173ff)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,12-75,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_01c4488a68699f466c59799f5c1173ff))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_01c4488a68699f466c59799f5c1173ff))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok
Tm_arrow_01c4488a68699f466c59799f5c1173ff))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,15-76,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__1 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'b
(declare-fun Tm_arrow_f317591858699585c67fe4ba8664e34c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f317591858699585c67fe4ba8664e34c
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f317591858699585c67fe4ba8664e34c
Tm_type)
:named kinding_Tm_arrow_f317591858699585c67fe4ba8664e34c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f317591858699585c67fe4ba8664e34c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f317591858699585c67fe4ba8664e34c))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f317591858699585c67fe4ba8664e34c))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f317591858699585c67fe4ba8664e34c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f317591858699585c67fe4ba8664e34c)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,15-75,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f317591858699585c67fe4ba8664e34c))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_f317591858699585c67fe4ba8664e34c))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok
Tm_arrow_f317591858699585c67fe4ba8664e34c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,25-76,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__2 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'c
(declare-fun Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c
Tm_type)
:named kinding_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,18-75,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok
Tm_arrow_44afce9d86f095aacc82b3ea2e0e223c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,35-76,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__3 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'd
(declare-fun Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35
Tm_type)
:named kinding_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,21-75,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok
Tm_arrow_e857539d4cc5be0510cbcfb97cb64b35))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,45-76,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__4 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'e
(declare-fun Tm_arrow_a249d3d5ba06026b12d41e289bb88061 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a249d3d5ba06026b12d41e289bb88061
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_a249d3d5ba06026b12d41e289bb88061
Tm_type)
:named kinding_Tm_arrow_a249d3d5ba06026b12d41e289bb88061))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a249d3d5ba06026b12d41e289bb88061)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a249d3d5ba06026b12d41e289bb88061))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_a249d3d5ba06026b12d41e289bb88061))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_a249d3d5ba06026b12d41e289bb88061))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a249d3d5ba06026b12d41e289bb88061)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,24-75,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a249d3d5ba06026b12d41e289bb88061))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_a249d3d5ba06026b12d41e289bb88061))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok
Tm_arrow_a249d3d5ba06026b12d41e289bb88061))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,55-76,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__5 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'f
(declare-fun Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00
Tm_type)
:named kinding_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,27-75,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok
Tm_arrow_bf614c740d11cac9b5f8eb20b24c7d00))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,65-76,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__6 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) -> 'g
(declare-fun Tm_arrow_e775fbf03b08091e48143165286522f7 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e775fbf03b08091e48143165286522f7
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_e775fbf03b08091e48143165286522f7
Tm_type)
:named kinding_Tm_arrow_e775fbf03b08091e48143165286522f7))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e775fbf03b08091e48143165286522f7)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e775fbf03b08091e48143165286522f7))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_e775fbf03b08091e48143165286522f7))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_e775fbf03b08091e48143165286522f7))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e775fbf03b08091e48143165286522f7)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple7 @x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(75,30-75,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e775fbf03b08091e48143165286522f7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_e775fbf03b08091e48143165286522f7))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple7__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok
Tm_arrow_e775fbf03b08091e48143165286522f7))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple7__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple7__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
(FStar.Pervasives.Native.tuple7 @x0
@x1
@x2
@x3
@x4
@x5
@x6)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple7__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple7__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple7__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(76,75-76,77)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
(FStar.Pervasives.Native.Mktuple7__7 @x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple7__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid proj_equation_FStar.Pervasives.Native.Mktuple7__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple7__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple7__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple7__item___7/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple8 (Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple8@x7 (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: Mktuple8
(declare-fun FStar.Pervasives.Native.Mktuple8@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> _7: 'g -> _8: 'h   -> (((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h
(declare-fun Tm_arrow_e922a339a0aa0f375ed7113049811583 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e922a339a0aa0f375ed7113049811583
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_e922a339a0aa0f375ed7113049811583
Tm_type)
:named kinding_Tm_arrow_e922a339a0aa0f375ed7113049811583))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e922a339a0aa0f375ed7113049811583)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e922a339a0aa0f375ed7113049811583))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_e922a339a0aa0f375ed7113049811583))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_e922a339a0aa0f375ed7113049811583))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e922a339a0aa0f375ed7113049811583)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2)
(HasType @x11
@x3)
(HasType @x12
@x4)
(HasType @x13
@x5)
(HasType @x14
@x6)
(HasType @x15
@x7)
(HasType @x16
@x8))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2)
(HasType @x11
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2)
(HasType @x11
@x3)
(HasType @x12
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2)
(HasType @x11
@x3)
(HasType @x12
@x4)
(HasType @x13
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2)
(HasType @x11
@x3)
(HasType @x12
@x4)
(HasType @x13
@x5)
(HasType @x14
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(81,7-81,37)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
@x1)
(HasType @x10
@x2)
(HasType @x11
@x3)
(HasType @x12
@x4)
(HasType @x13
@x5)
(HasType @x14
@x6)
(HasType @x15
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583.16))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e922a339a0aa0f375ed7113049811583))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_e922a339a0aa0f375ed7113049811583))

; <Start encoding FStar.Pervasives.Native.tuple8>


; <start constructor FStar.Pervasives.Native.tuple8>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= 261
(Term_constr_id (FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
 

:pattern ((FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid constructor_distinct_FStar.Pervasives.Native.tuple8))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple8))))

; </end constructor FStar.Pervasives.Native.tuple8>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (= 262
(Term_constr_id FStar.Pervasives.Native.tuple8@tok))
:named fresh_token_FStar.Pervasives.Native.tuple8@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))

:pattern ((FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid token_correspondence_FStar.Pervasives.Native.tuple8@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple8@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple8@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple8@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple8@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple8@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(HasType (FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid kinding_FStar.Pervasives.Native.tuple8@tok.7))
)
:named kinding_FStar.Pervasives.Native.tuple8@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple8 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
(= (FStar.Pervasives.Native.tuple8 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple8 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
:qid FStar.Pervasives.Native_pretyping_db058ca688f8c62b81e4ac913379b0df))

:named FStar.Pervasives.Native_pretyping_db058ca688f8c62b81e4ac913379b0df))

; </end encoding FStar.Pervasives.Native.tuple8>


; <Start encoding FStar.Pervasives.Native.Mktuple8>


; <start constructor FStar.Pervasives.Native.Mktuple8>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= 268
(Term_constr_id (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple8))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__a (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__b (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__c (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__d (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__e (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__f (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__g (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__h (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__1 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__2 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__3 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__4 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__5 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__6 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__7 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (FStar.Pervasives.Native.Mktuple8__8 (FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple8__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple8__8))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (= 271
(Term_constr_id FStar.Pervasives.Native.Mktuple8@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple8@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple8@tok
Tm_arrow_e922a339a0aa0f375ed7113049811583))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple8@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple8@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple8@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple8@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid equality_tok_FStar.Pervasives.Native.Mktuple8@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple8@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
@x1)
(HasTypeFuel @u0
@x10
@x2)
(HasTypeFuel @u0
@x11
@x3)
(HasTypeFuel @u0
@x12
@x4)
(HasTypeFuel @u0
@x13
@x5)
(HasTypeFuel @u0
@x14
@x6)
(HasTypeFuel @u0
@x15
@x7)
(HasTypeFuel @u0
@x16
@x8))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple8@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple8@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(FStar.Pervasives.Native.tuple8 @x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24))
(and (HasTypeFuel @u0
@x24
Tm_type)
(HasTypeFuel @u0
@x16
@x24)
(HasTypeFuel @u0
@x23
Tm_type)
(HasTypeFuel @u0
@x15
@x23)
(HasTypeFuel @u0
@x22
Tm_type)
(HasTypeFuel @u0
@x14
@x22)
(HasTypeFuel @u0
@x21
Tm_type)
(HasTypeFuel @u0
@x13
@x21)
(HasTypeFuel @u0
@x20
Tm_type)
(HasTypeFuel @u0
@x12
@x20)
(HasTypeFuel @u0
@x19
Tm_type)
(HasTypeFuel @u0
@x11
@x19)
(HasTypeFuel @u0
@x18
Tm_type)
(HasTypeFuel @u0
@x10
@x18)
(HasTypeFuel @u0
@x17
Tm_type)
(HasTypeFuel @u0
@x9
@x17)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
@x1)
(HasTypeFuel @u0
@x10
@x2)
(HasTypeFuel @u0
@x11
@x3)
(HasTypeFuel @u0
@x12
@x4)
(HasTypeFuel @u0
@x13
@x5)
(HasTypeFuel @u0
@x14
@x6)
(HasTypeFuel @u0
@x15
@x7)
(HasTypeFuel @u0
@x16
@x8)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(FStar.Pervasives.Native.tuple8 @x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
:qid data_elim_FStar.Pervasives.Native.Mktuple8))

:named data_elim_FStar.Pervasives.Native.Mktuple8))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(FStar.Pervasives.Native.tuple8 @x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x9
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x10
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x11
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x12
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x13
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(FStar.Pervasives.Native.tuple8 @x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple8))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple8))

; </end encoding FStar.Pervasives.Native.Mktuple8>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,5-79,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple8 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
(and (is-FStar.Pervasives.Native.Mktuple8 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple8__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple8__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple8__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple8__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple8__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple8__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple8__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple8__h @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple8 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple8))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple8))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple8__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple8__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple8__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
:qid assumption_FStar.Pervasives.Native.tuple8__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple8__uu___haseq))

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


; <Start encoding FStar.Pervasives.Native.uu___is_Mktuple8>

(declare-fun FStar.Pervasives.Native.uu___is_Mktuple8 (Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> Prims.bool
(declare-fun Tm_arrow_ee31533e24c78558f4566668a6ec027c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ee31533e24c78558f4566668a6ec027c
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_ee31533e24c78558f4566668a6ec027c
Tm_type)
:named kinding_Tm_arrow_ee31533e24c78558f4566668a6ec027c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ee31533e24c78558f4566668a6ec027c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ee31533e24c78558f4566668a6ec027c))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_ee31533e24c78558f4566668a6ec027c))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_ee31533e24c78558f4566668a6ec027c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ee31533e24c78558f4566668a6ec027c)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c.9))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ee31533e24c78558f4566668a6ec027c))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_ee31533e24c78558f4566668a6ec027c))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.uu___is_Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple8))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple8@tok
Tm_arrow_ee31533e24c78558f4566668a6ec027c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.uu___is_Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple8@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple8))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple8))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple8))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,4-80,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(BoxBool (is-FStar.Pervasives.Native.Mktuple8 @x8)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid disc_equation_FStar.Pervasives.Native.Mktuple8))

:named disc_equation_FStar.Pervasives.Native.Mktuple8))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple8>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'a
(declare-fun Tm_arrow_c971649e117e4941e7317eff508d5ea7 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c971649e117e4941e7317eff508d5ea7
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_c971649e117e4941e7317eff508d5ea7
Tm_type)
:named kinding_Tm_arrow_c971649e117e4941e7317eff508d5ea7))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c971649e117e4941e7317eff508d5ea7)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c971649e117e4941e7317eff508d5ea7))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_c971649e117e4941e7317eff508d5ea7))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_c971649e117e4941e7317eff508d5ea7))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c971649e117e4941e7317eff508d5ea7)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,12-79,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c971649e117e4941e7317eff508d5ea7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_c971649e117e4941e7317eff508d5ea7))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok
Tm_arrow_c971649e117e4941e7317eff508d5ea7))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,15-80,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__1 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'b
(declare-fun Tm_arrow_97dd51e3888c1c543d8f6c73d1808548 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_97dd51e3888c1c543d8f6c73d1808548
Tm_type)
:named kinding_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_97dd51e3888c1c543d8f6c73d1808548)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_97dd51e3888c1c543d8f6c73d1808548)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,15-79,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok
Tm_arrow_97dd51e3888c1c543d8f6c73d1808548))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,25-80,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__2 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'c
(declare-fun Tm_arrow_3931d1873633dc65fed4e022ee3df3ca () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3931d1873633dc65fed4e022ee3df3ca
Tm_type)
:named kinding_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3931d1873633dc65fed4e022ee3df3ca)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3931d1873633dc65fed4e022ee3df3ca)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,18-79,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok
Tm_arrow_3931d1873633dc65fed4e022ee3df3ca))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,35-80,37)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__3 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'd
(declare-fun Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8
Tm_type)
:named kinding_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,21-79,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok
Tm_arrow_5c791e62f9472e4c351c2befb2b7a3d8))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,45-80,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__4 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'e
(declare-fun Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce
Tm_type)
:named kinding_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,24-79,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok
Tm_arrow_7ef7cac898ca0ef25893959e91d8c6ce))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,55-80,57)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__5 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'f
(declare-fun Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb
Tm_type)
:named kinding_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,27-79,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok
Tm_arrow_b0ae5f58a7fa002e0313b58bf5fc74cb))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,65-80,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__6 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'g
(declare-fun Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590
Tm_type)
:named kinding_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,30-79,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok
Tm_arrow_7fcd94f7549ca8acfadc26bc5b82f590))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,75-80,77)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__7 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) -> 'h
(declare-fun Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573
Tm_type)
:named kinding_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(79,33-79,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573.9))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple8__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok
Tm_arrow_feaaf61fa62fef18c5ee7c39e9f86573))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple8__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple8__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
(FStar.Pervasives.Native.tuple8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple8__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple8__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple8__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(80,85-80,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.Native.Mktuple8__8 @x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple8__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid proj_equation_FStar.Pervasives.Native.Mktuple8__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple8__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple8__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple8__item___8/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple9 (Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x7 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple9@x8 (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: Mktuple9
(declare-fun FStar.Pervasives.Native.Mktuple9@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> _7: 'g -> _8: 'h -> _9: 'i   -> ((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i
(declare-fun Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60
Tm_type)
:named kinding_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3)
(HasType @x13
@x4)
(HasType @x14
@x5)
(HasType @x15
@x6)
(HasType @x16
@x7)
(HasType @x17
@x8)
(HasType @x18
@x9))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3)
(HasType @x13
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3)
(HasType @x13
@x4)
(HasType @x14
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3)
(HasType @x13
@x4)
(HasType @x14
@x5)
(HasType @x15
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.16))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3)
(HasType @x13
@x4)
(HasType @x14
@x5)
(HasType @x15
@x6)
(HasType @x16
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.17))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(94,7-94,40)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
@x1)
(HasType @x11
@x2)
(HasType @x12
@x3)
(HasType @x13
@x4)
(HasType @x14
@x5)
(HasType @x15
@x6)
(HasType @x16
@x7)
(HasType @x17
@x8))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60.18))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))

; <Start encoding FStar.Pervasives.Native.tuple9>


; <start constructor FStar.Pervasives.Native.tuple9>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= 290
(Term_constr_id (FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
 

:pattern ((FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid constructor_distinct_FStar.Pervasives.Native.tuple9))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple9))))

; </end constructor FStar.Pervasives.Native.tuple9>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (= 291
(Term_constr_id FStar.Pervasives.Native.tuple9@tok))
:named fresh_token_FStar.Pervasives.Native.tuple9@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))

:pattern ((FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid token_correspondence_FStar.Pervasives.Native.tuple9@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple9@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple9@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple9@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple9@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple9@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(HasType (FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))
:qid kinding_FStar.Pervasives.Native.tuple9@tok.8))
)
:named kinding_FStar.Pervasives.Native.tuple9@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple9 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
(= (FStar.Pervasives.Native.tuple9 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple9 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
:qid FStar.Pervasives.Native_pretyping_9af262328ba534fb9ece59f56c2757de))

:named FStar.Pervasives.Native_pretyping_9af262328ba534fb9ece59f56c2757de))

; </end encoding FStar.Pervasives.Native.tuple9>


; <Start encoding FStar.Pervasives.Native.Mktuple9>


; <start constructor FStar.Pervasives.Native.Mktuple9>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= 297
(Term_constr_id (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17)))
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple9))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple9))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__a (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__b (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__c (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__d (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__e (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__f (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__g (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__h (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__i (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__i))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__i))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__1 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__2 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__3 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__4 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__5 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__6 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__7 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__8 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x16)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (FStar.Pervasives.Native.Mktuple9__9 (FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
@x17)
 

:pattern ((FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple9__9))

:named projection_inverse_FStar.Pervasives.Native.Mktuple9__9))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (= 300
(Term_constr_id FStar.Pervasives.Native.Mktuple9@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple9@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple9@tok
Tm_arrow_0c6bc368a301d7de6e1939ebea91ee60))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple9@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple9@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple9@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple9@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
(FStar.Pervasives.Native.Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid equality_tok_FStar.Pervasives.Native.Mktuple9@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple9@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
@x1)
(HasTypeFuel @u0
@x11
@x2)
(HasTypeFuel @u0
@x12
@x3)
(HasTypeFuel @u0
@x13
@x4)
(HasTypeFuel @u0
@x14
@x5)
(HasTypeFuel @u0
@x15
@x6)
(HasTypeFuel @u0
@x16
@x7)
(HasTypeFuel @u0
@x17
@x8)
(HasTypeFuel @u0
@x18
@x9))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple9@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple9@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)
(FStar.Pervasives.Native.tuple9 @x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
(and (HasTypeFuel @u0
@x27
Tm_type)
(HasTypeFuel @u0
@x18
@x27)
(HasTypeFuel @u0
@x26
Tm_type)
(HasTypeFuel @u0
@x17
@x26)
(HasTypeFuel @u0
@x25
Tm_type)
(HasTypeFuel @u0
@x16
@x25)
(HasTypeFuel @u0
@x24
Tm_type)
(HasTypeFuel @u0
@x15
@x24)
(HasTypeFuel @u0
@x23
Tm_type)
(HasTypeFuel @u0
@x14
@x23)
(HasTypeFuel @u0
@x22
Tm_type)
(HasTypeFuel @u0
@x13
@x22)
(HasTypeFuel @u0
@x21
Tm_type)
(HasTypeFuel @u0
@x12
@x21)
(HasTypeFuel @u0
@x20
Tm_type)
(HasTypeFuel @u0
@x11
@x20)
(HasTypeFuel @u0
@x19
Tm_type)
(HasTypeFuel @u0
@x10
@x19)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
@x1)
(HasTypeFuel @u0
@x11
@x2)
(HasTypeFuel @u0
@x12
@x3)
(HasTypeFuel @u0
@x13
@x4)
(HasTypeFuel @u0
@x14
@x5)
(HasTypeFuel @u0
@x15
@x6)
(HasTypeFuel @u0
@x16
@x7)
(HasTypeFuel @u0
@x17
@x8)
(HasTypeFuel @u0
@x18
@x9)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)
(FStar.Pervasives.Native.tuple9 @x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27)))
:qid data_elim_FStar.Pervasives.Native.Mktuple9))

:named data_elim_FStar.Pervasives.Native.Mktuple9))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)
(FStar.Pervasives.Native.tuple9 @x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x10
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x11
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x12
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x13
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x17
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x18
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18)
(FStar.Pervasives.Native.tuple9 @x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple9))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple9))

; </end encoding FStar.Pervasives.Native.Mktuple9>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,5-83,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple9 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
(and (is-FStar.Pervasives.Native.Mktuple9 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple9__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple9__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple9__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple9__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple9__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple9__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple9__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple9__h @x1))
(= @x10
(FStar.Pervasives.Native.Mktuple9__i @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple9 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple9))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple9))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple9__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple9__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple9__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7))
(Valid (Prims.hasEq @x8)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
:qid assumption_FStar.Pervasives.Native.tuple9__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple9__uu___haseq))

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


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> Prims.bool
(declare-fun Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38
Tm_type)
:named kinding_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.9))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38.10))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.uu___is_Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple9))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple9@tok
Tm_arrow_9ac8f39c7b1df1e87db7c9bf5bc37a38))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.uu___is_Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple9@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple9))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple9))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple9))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(84,4-84,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(BoxBool (is-FStar.Pervasives.Native.Mktuple9 @x9)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid disc_equation_FStar.Pervasives.Native.Mktuple9))

:named disc_equation_FStar.Pervasives.Native.Mktuple9))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple9>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple9/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'a
(declare-fun Tm_arrow_270119cc1f13c9afeb25322d78efc328 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_270119cc1f13c9afeb25322d78efc328
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_270119cc1f13c9afeb25322d78efc328
Tm_type)
:named kinding_Tm_arrow_270119cc1f13c9afeb25322d78efc328))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_270119cc1f13c9afeb25322d78efc328)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_270119cc1f13c9afeb25322d78efc328))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_270119cc1f13c9afeb25322d78efc328))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_270119cc1f13c9afeb25322d78efc328))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_270119cc1f13c9afeb25322d78efc328)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,12-83,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_270119cc1f13c9afeb25322d78efc328))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_270119cc1f13c9afeb25322d78efc328))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok
Tm_arrow_270119cc1f13c9afeb25322d78efc328))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(85,6-85,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__1 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'b
(declare-fun Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613
Tm_type)
:named kinding_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,15-83,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok
Tm_arrow_3c368dee2c86a1af7bd7ea91baab7613))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(86,6-86,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__2 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'c
(declare-fun Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3
Tm_type)
:named kinding_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,18-83,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok
Tm_arrow_e9c745e2da3dec50930b0a7e01a11cc3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(87,6-87,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__3 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'd
(declare-fun Tm_arrow_a82ff41c5c66cd37481c83584c94a54d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_a82ff41c5c66cd37481c83584c94a54d
Tm_type)
:named kinding_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a82ff41c5c66cd37481c83584c94a54d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a82ff41c5c66cd37481c83584c94a54d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,21-83,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok
Tm_arrow_a82ff41c5c66cd37481c83584c94a54d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(88,6-88,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__4 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'e
(declare-fun Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de
Tm_type)
:named kinding_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,24-83,26)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok
Tm_arrow_1b3b4c5e68fdf7277f64bde93e6534de))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(89,6-89,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__5 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'f
(declare-fun Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058
Tm_type)
:named kinding_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,27-83,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok
Tm_arrow_837f1324f6fa51bb8a0e45ee48e4e058))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(90,6-90,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__6 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'g
(declare-fun Tm_arrow_a7562220963e3431d35de76c3c9c87b9 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a7562220963e3431d35de76c3c9c87b9
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_a7562220963e3431d35de76c3c9c87b9
Tm_type)
:named kinding_Tm_arrow_a7562220963e3431d35de76c3c9c87b9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a7562220963e3431d35de76c3c9c87b9)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a7562220963e3431d35de76c3c9c87b9))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_a7562220963e3431d35de76c3c9c87b9))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_a7562220963e3431d35de76c3c9c87b9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a7562220963e3431d35de76c3c9c87b9)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,30-83,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a7562220963e3431d35de76c3c9c87b9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_a7562220963e3431d35de76c3c9c87b9))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok
Tm_arrow_a7562220963e3431d35de76c3c9c87b9))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(91,6-91,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__7 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'h
(declare-fun Tm_arrow_861b810bc1c20bbd221cecbce824b695 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_861b810bc1c20bbd221cecbce824b695
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_861b810bc1c20bbd221cecbce824b695
Tm_type)
:named kinding_Tm_arrow_861b810bc1c20bbd221cecbce824b695))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_861b810bc1c20bbd221cecbce824b695)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_861b810bc1c20bbd221cecbce824b695))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_861b810bc1c20bbd221cecbce824b695))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_861b810bc1c20bbd221cecbce824b695))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_861b810bc1c20bbd221cecbce824b695)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,33-83,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_861b810bc1c20bbd221cecbce824b695))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_861b810bc1c20bbd221cecbce824b695))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok
Tm_arrow_861b810bc1c20bbd221cecbce824b695))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(92,6-92,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__8 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) -> 'i
(declare-fun Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc
Tm_type)
:named kinding_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(83,36-83,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc.10))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___9))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple9__item___9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok
Tm_arrow_9a54b18d8e08fdf0e20244b3f960c9dc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple9__item___9@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___9))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple9__item___9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
(FStar.Pervasives.Native.tuple9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple9__item___9))

:named typing_FStar.Pervasives.Native.__proj__Mktuple9__item___9))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple9__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(93,6-93,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
(FStar.Pervasives.Native.Mktuple9__9 @x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple9__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid proj_equation_FStar.Pervasives.Native.Mktuple9__9))

:named proj_equation_FStar.Pervasives.Native.Mktuple9__9))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple9__item___9>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple9__item___9/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple10 (Term Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x7 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x8 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple10@x9 (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: Mktuple10
(declare-fun FStar.Pervasives.Native.Mktuple10@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> _7: 'g -> _8: 'h -> _9: 'i -> _10: 'j   -> (((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j
(declare-fun Tm_arrow_61d31241317018093b2245d256adbcb5 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_61d31241317018093b2245d256adbcb5
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_61d31241317018093b2245d256adbcb5
Tm_type)
:named kinding_Tm_arrow_61d31241317018093b2245d256adbcb5))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_61d31241317018093b2245d256adbcb5)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_61d31241317018093b2245d256adbcb5))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_61d31241317018093b2245d256adbcb5))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_61d31241317018093b2245d256adbcb5))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_61d31241317018093b2245d256adbcb5)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4)
(HasType @x15
@x5)
(HasType @x16
@x6)
(HasType @x17
@x7)
(HasType @x18
@x8)
(HasType @x19
@x9)
(HasType @x20
@x10))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4)
(HasType @x15
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.16))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4)
(HasType @x15
@x5)
(HasType @x16
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.17))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4)
(HasType @x15
@x5)
(HasType @x16
@x6)
(HasType @x17
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.18))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4)
(HasType @x15
@x5)
(HasType @x16
@x6)
(HasType @x17
@x7)
(HasType @x18
@x8))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.19))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(108,7-108,44)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
@x1)
(HasType @x12
@x2)
(HasType @x13
@x3)
(HasType @x14
@x4)
(HasType @x15
@x5)
(HasType @x16
@x6)
(HasType @x17
@x7)
(HasType @x18
@x8)
(HasType @x19
@x9))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5.20))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_61d31241317018093b2245d256adbcb5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_61d31241317018093b2245d256adbcb5))

; <Start encoding FStar.Pervasives.Native.tuple10>


; <start constructor FStar.Pervasives.Native.tuple10>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= 321
(Term_constr_id (FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
 

:pattern ((FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid constructor_distinct_FStar.Pervasives.Native.tuple10))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple10))))

; </end constructor FStar.Pervasives.Native.tuple10>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (= 322
(Term_constr_id FStar.Pervasives.Native.tuple10@tok))
:named fresh_token_FStar.Pervasives.Native.tuple10@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))

:pattern ((FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid token_correspondence_FStar.Pervasives.Native.tuple10@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple10@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple10@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple10@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple10@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple10@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(HasType (FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))
:qid kinding_FStar.Pervasives.Native.tuple10@tok.9))
)
:named kinding_FStar.Pervasives.Native.tuple10@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple10 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
(= (FStar.Pervasives.Native.tuple10 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple10 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
:qid FStar.Pervasives.Native_pretyping_4d5b126872c45416c34a013a6060deef))

:named FStar.Pervasives.Native_pretyping_4d5b126872c45416c34a013a6060deef))

; </end encoding FStar.Pervasives.Native.tuple10>


; <Start encoding FStar.Pervasives.Native.Mktuple10>


; <start constructor FStar.Pervasives.Native.Mktuple10>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= 328
(Term_constr_id (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19)))
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple10))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple10))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__a (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__b (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__c (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__d (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__e (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__f (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__g (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__h (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__i (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__i))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__i))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__j (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__j))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__j))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__1 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__2 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__3 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__4 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__5 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__6 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__7 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x16)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__8 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x17)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__9 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x18)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__9))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__9))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (FStar.Pervasives.Native.Mktuple10__10 (FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
@x19)
 

:pattern ((FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple10__10))

:named projection_inverse_FStar.Pervasives.Native.Mktuple10__10))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (= 331
(Term_constr_id FStar.Pervasives.Native.Mktuple10@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple10@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple10@tok
Tm_arrow_61d31241317018093b2245d256adbcb5))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple10@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple10@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple10@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple10@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
(FStar.Pervasives.Native.Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19))
:qid equality_tok_FStar.Pervasives.Native.Mktuple10@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple10@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
@x1)
(HasTypeFuel @u0
@x12
@x2)
(HasTypeFuel @u0
@x13
@x3)
(HasTypeFuel @u0
@x14
@x4)
(HasTypeFuel @u0
@x15
@x5)
(HasTypeFuel @u0
@x16
@x6)
(HasTypeFuel @u0
@x17
@x7)
(HasTypeFuel @u0
@x18
@x8)
(HasTypeFuel @u0
@x19
@x9)
(HasTypeFuel @u0
@x20
@x10))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple10@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple10@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)
(FStar.Pervasives.Native.tuple10 @x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30))
(and (HasTypeFuel @u0
@x30
Tm_type)
(HasTypeFuel @u0
@x20
@x30)
(HasTypeFuel @u0
@x29
Tm_type)
(HasTypeFuel @u0
@x19
@x29)
(HasTypeFuel @u0
@x28
Tm_type)
(HasTypeFuel @u0
@x18
@x28)
(HasTypeFuel @u0
@x27
Tm_type)
(HasTypeFuel @u0
@x17
@x27)
(HasTypeFuel @u0
@x26
Tm_type)
(HasTypeFuel @u0
@x16
@x26)
(HasTypeFuel @u0
@x25
Tm_type)
(HasTypeFuel @u0
@x15
@x25)
(HasTypeFuel @u0
@x24
Tm_type)
(HasTypeFuel @u0
@x14
@x24)
(HasTypeFuel @u0
@x23
Tm_type)
(HasTypeFuel @u0
@x13
@x23)
(HasTypeFuel @u0
@x22
Tm_type)
(HasTypeFuel @u0
@x12
@x22)
(HasTypeFuel @u0
@x21
Tm_type)
(HasTypeFuel @u0
@x11
@x21)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
@x1)
(HasTypeFuel @u0
@x12
@x2)
(HasTypeFuel @u0
@x13
@x3)
(HasTypeFuel @u0
@x14
@x4)
(HasTypeFuel @u0
@x15
@x5)
(HasTypeFuel @u0
@x16
@x6)
(HasTypeFuel @u0
@x17
@x7)
(HasTypeFuel @u0
@x18
@x8)
(HasTypeFuel @u0
@x19
@x9)
(HasTypeFuel @u0
@x20
@x10)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)
(FStar.Pervasives.Native.tuple10 @x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30)))
:qid data_elim_FStar.Pervasives.Native.Mktuple10))

:named data_elim_FStar.Pervasives.Native.Mktuple10))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)
(FStar.Pervasives.Native.tuple10 @x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x11
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x12
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x13
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x17
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x18
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x19
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x20
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20)
(FStar.Pervasives.Native.tuple10 @x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple10))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple10))

; </end encoding FStar.Pervasives.Native.Mktuple10>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,5-96,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple10 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
(and (is-FStar.Pervasives.Native.Mktuple10 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple10__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple10__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple10__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple10__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple10__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple10__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple10__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple10__h @x1))
(= @x10
(FStar.Pervasives.Native.Mktuple10__i @x1))
(= @x11
(FStar.Pervasives.Native.Mktuple10__j @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple10 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple10))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple10))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple10__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple10__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple10__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7))
(Valid (Prims.hasEq @x8))
(Valid (Prims.hasEq @x9)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
:qid assumption_FStar.Pervasives.Native.tuple10__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple10__uu___haseq))

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


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> Prims.bool
(declare-fun Tm_arrow_f27282a056f525d8710bf32204d252ec () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f27282a056f525d8710bf32204d252ec
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f27282a056f525d8710bf32204d252ec
Tm_type)
:named kinding_Tm_arrow_f27282a056f525d8710bf32204d252ec))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f27282a056f525d8710bf32204d252ec)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f27282a056f525d8710bf32204d252ec))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f27282a056f525d8710bf32204d252ec))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f27282a056f525d8710bf32204d252ec))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f27282a056f525d8710bf32204d252ec)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.9))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.10))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec.11))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f27282a056f525d8710bf32204d252ec))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_f27282a056f525d8710bf32204d252ec))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple10@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.uu___is_Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple10))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple10))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple10@tok
Tm_arrow_f27282a056f525d8710bf32204d252ec))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple10@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.uu___is_Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple10.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple10@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple10))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple10))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple10))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple10))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(97,4-97,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(BoxBool (is-FStar.Pervasives.Native.Mktuple10 @x10)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid disc_equation_FStar.Pervasives.Native.Mktuple10))

:named disc_equation_FStar.Pervasives.Native.Mktuple10))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple10>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple10/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'a
(declare-fun Tm_arrow_c581e9177cd071a1b6e057fca49ea75b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_c581e9177cd071a1b6e057fca49ea75b
Tm_type)
:named kinding_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c581e9177cd071a1b6e057fca49ea75b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c581e9177cd071a1b6e057fca49ea75b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,13-96,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok
Tm_arrow_c581e9177cd071a1b6e057fca49ea75b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(98,6-98,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__1 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'b
(declare-fun Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149
Tm_type)
:named kinding_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,16-96,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok
Tm_arrow_ae4b2db87d7c69a8380f4d5ae20f2149))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(99,6-99,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__2 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'c
(declare-fun Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a
Tm_type)
:named kinding_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,19-96,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok
Tm_arrow_a21274cb112dc6619b2bde244e6a0f9a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(100,6-100,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__3 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'd
(declare-fun Tm_arrow_9a051d5cacf4367d170d590ba8bb720d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9a051d5cacf4367d170d590ba8bb720d
Tm_type)
:named kinding_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9a051d5cacf4367d170d590ba8bb720d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9a051d5cacf4367d170d590ba8bb720d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,22-96,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok
Tm_arrow_9a051d5cacf4367d170d590ba8bb720d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(101,6-101,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__4 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'e
(declare-fun Tm_arrow_bbd73769b626202d4de52d4d60cd3b75 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_bbd73769b626202d4de52d4d60cd3b75
Tm_type)
:named kinding_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_bbd73769b626202d4de52d4d60cd3b75)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_bbd73769b626202d4de52d4d60cd3b75)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,25-96,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok
Tm_arrow_bbd73769b626202d4de52d4d60cd3b75))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(102,6-102,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__5 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'f
(declare-fun Tm_arrow_7ceeded5a3852448c1a5406becbd990e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7ceeded5a3852448c1a5406becbd990e
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7ceeded5a3852448c1a5406becbd990e
Tm_type)
:named kinding_Tm_arrow_7ceeded5a3852448c1a5406becbd990e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7ceeded5a3852448c1a5406becbd990e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7ceeded5a3852448c1a5406becbd990e))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7ceeded5a3852448c1a5406becbd990e))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7ceeded5a3852448c1a5406becbd990e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7ceeded5a3852448c1a5406becbd990e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,28-96,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7ceeded5a3852448c1a5406becbd990e))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7ceeded5a3852448c1a5406becbd990e))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok
Tm_arrow_7ceeded5a3852448c1a5406becbd990e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(103,6-103,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__6 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'g
(declare-fun Tm_arrow_c68947c71d484ad43cd50646c4e1daf4 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_c68947c71d484ad43cd50646c4e1daf4
Tm_type)
:named kinding_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c68947c71d484ad43cd50646c4e1daf4)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c68947c71d484ad43cd50646c4e1daf4)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,31-96,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok
Tm_arrow_c68947c71d484ad43cd50646c4e1daf4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(104,6-104,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__7 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'h
(declare-fun Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6
Tm_type)
:named kinding_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,34-96,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok
Tm_arrow_e7b9ff90289491020fe84c6ab3bc60c6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(105,6-105,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__8 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'i
(declare-fun Tm_arrow_6dbb3170f112f78092d1caee0b341678 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6dbb3170f112f78092d1caee0b341678
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_6dbb3170f112f78092d1caee0b341678
Tm_type)
:named kinding_Tm_arrow_6dbb3170f112f78092d1caee0b341678))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6dbb3170f112f78092d1caee0b341678)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6dbb3170f112f78092d1caee0b341678))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_6dbb3170f112f78092d1caee0b341678))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_6dbb3170f112f78092d1caee0b341678))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6dbb3170f112f78092d1caee0b341678)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,37-96,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6dbb3170f112f78092d1caee0b341678))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_6dbb3170f112f78092d1caee0b341678))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___9))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok
Tm_arrow_6dbb3170f112f78092d1caee0b341678))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___9@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___9))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___9))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___9))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(106,6-106,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__9 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__9))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__9))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___9>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___9/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) -> 'j
(declare-fun Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf
Tm_type)
:named kinding_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(96,40-96,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf.11))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___10))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple10__item___10))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok
Tm_arrow_45598a99c0a7fcc1bf2258b9ad4256cf))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___10.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple10__item___10@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___10))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple10__item___10))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
(FStar.Pervasives.Native.tuple10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple10__item___10))

:named typing_FStar.Pervasives.Native.__proj__Mktuple10__item___10))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple10__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(107,6-107,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
(FStar.Pervasives.Native.Mktuple10__10 @x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple10__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid proj_equation_FStar.Pervasives.Native.Mktuple10__10))

:named proj_equation_FStar.Pervasives.Native.Mktuple10__10))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple10__item___10>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple10__item___10/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple11 (Term Term Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x7 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x8 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x9 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple11@x10 (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: Mktuple11
(declare-fun FStar.Pervasives.Native.Mktuple11@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a ->     _2: 'b ->     _3: 'c ->     _4: 'd ->     _5: 'e ->     _6: 'f ->     _7: 'g ->     _8: 'h ->     _9: 'i ->     _10: 'j ->     _11: 'k   -> ((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k
(declare-fun Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32
Tm_type)
:named kinding_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5)
(HasType @x17
@x6)
(HasType @x18
@x7)
(HasType @x19
@x8)
(HasType @x20
@x9)
(HasType @x21
@x10)
(HasType @x22
@x11))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.16))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.17))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5)
(HasType @x17
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.18))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5)
(HasType @x17
@x6)
(HasType @x18
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.19))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5)
(HasType @x17
@x6)
(HasType @x18
@x7)
(HasType @x19
@x8))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.20))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5)
(HasType @x17
@x6)
(HasType @x18
@x7)
(HasType @x19
@x8)
(HasType @x20
@x9))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.21))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(123,7-123,47)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
@x1)
(HasType @x13
@x2)
(HasType @x14
@x3)
(HasType @x15
@x4)
(HasType @x16
@x5)
(HasType @x17
@x6)
(HasType @x18
@x7)
(HasType @x19
@x8)
(HasType @x20
@x9)
(HasType @x21
@x10))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32.22))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))

; <Start encoding FStar.Pervasives.Native.tuple11>


; <start constructor FStar.Pervasives.Native.tuple11>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= 354
(Term_constr_id (FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
 

:pattern ((FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid constructor_distinct_FStar.Pervasives.Native.tuple11))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple11))))

; </end constructor FStar.Pervasives.Native.tuple11>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (= 355
(Term_constr_id FStar.Pervasives.Native.tuple11@tok))
:named fresh_token_FStar.Pervasives.Native.tuple11@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))

:pattern ((FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid token_correspondence_FStar.Pervasives.Native.tuple11@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple11@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple11@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple11@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple11@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple11@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(HasType (FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))
:qid kinding_FStar.Pervasives.Native.tuple11@tok.10))
)
:named kinding_FStar.Pervasives.Native.tuple11@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple11 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
(= (FStar.Pervasives.Native.tuple11 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple11 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
:qid FStar.Pervasives.Native_pretyping_217ba18a4f92d625109ad940d63ac946))

:named FStar.Pervasives.Native_pretyping_217ba18a4f92d625109ad940d63ac946))

; </end encoding FStar.Pervasives.Native.tuple11>


; <Start encoding FStar.Pervasives.Native.Mktuple11>


; <start constructor FStar.Pervasives.Native.Mktuple11>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= 361
(Term_constr_id (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21)))
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple11))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple11))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__a (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__b (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__c (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__d (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__e (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__f (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__g (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__h (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__i (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__i))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__i))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__j (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__j))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__j))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__k (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__k))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__k))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__1 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__2 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__3 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__4 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__5 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__6 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x16)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__7 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x17)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__8 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x18)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__9 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x19)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__9))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__9))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__10 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x20)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__10))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__10))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (FStar.Pervasives.Native.Mktuple11__11 (FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
@x21)
 

:pattern ((FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple11__11))

:named projection_inverse_FStar.Pervasives.Native.Mktuple11__11))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (= 364
(Term_constr_id FStar.Pervasives.Native.Mktuple11@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple11@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple11@tok
Tm_arrow_bf9783a1a3bf19ab918f42acff1daa32))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple11@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple11@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple11@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple11@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
(FStar.Pervasives.Native.Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21))
:qid equality_tok_FStar.Pervasives.Native.Mktuple11@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple11@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
@x1)
(HasTypeFuel @u0
@x13
@x2)
(HasTypeFuel @u0
@x14
@x3)
(HasTypeFuel @u0
@x15
@x4)
(HasTypeFuel @u0
@x16
@x5)
(HasTypeFuel @u0
@x17
@x6)
(HasTypeFuel @u0
@x18
@x7)
(HasTypeFuel @u0
@x19
@x8)
(HasTypeFuel @u0
@x20
@x9)
(HasTypeFuel @u0
@x21
@x10)
(HasTypeFuel @u0
@x22
@x11))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple11@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple11@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)
(FStar.Pervasives.Native.tuple11 @x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33))
(and (HasTypeFuel @u0
@x33
Tm_type)
(HasTypeFuel @u0
@x22
@x33)
(HasTypeFuel @u0
@x32
Tm_type)
(HasTypeFuel @u0
@x21
@x32)
(HasTypeFuel @u0
@x31
Tm_type)
(HasTypeFuel @u0
@x20
@x31)
(HasTypeFuel @u0
@x30
Tm_type)
(HasTypeFuel @u0
@x19
@x30)
(HasTypeFuel @u0
@x29
Tm_type)
(HasTypeFuel @u0
@x18
@x29)
(HasTypeFuel @u0
@x28
Tm_type)
(HasTypeFuel @u0
@x17
@x28)
(HasTypeFuel @u0
@x27
Tm_type)
(HasTypeFuel @u0
@x16
@x27)
(HasTypeFuel @u0
@x26
Tm_type)
(HasTypeFuel @u0
@x15
@x26)
(HasTypeFuel @u0
@x25
Tm_type)
(HasTypeFuel @u0
@x14
@x25)
(HasTypeFuel @u0
@x24
Tm_type)
(HasTypeFuel @u0
@x13
@x24)
(HasTypeFuel @u0
@x23
Tm_type)
(HasTypeFuel @u0
@x12
@x23)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
@x1)
(HasTypeFuel @u0
@x13
@x2)
(HasTypeFuel @u0
@x14
@x3)
(HasTypeFuel @u0
@x15
@x4)
(HasTypeFuel @u0
@x16
@x5)
(HasTypeFuel @u0
@x17
@x6)
(HasTypeFuel @u0
@x18
@x7)
(HasTypeFuel @u0
@x19
@x8)
(HasTypeFuel @u0
@x20
@x9)
(HasTypeFuel @u0
@x21
@x10)
(HasTypeFuel @u0
@x22
@x11)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)
(FStar.Pervasives.Native.tuple11 @x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33)))
:qid data_elim_FStar.Pervasives.Native.Mktuple11))

:named data_elim_FStar.Pervasives.Native.Mktuple11))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)
(FStar.Pervasives.Native.tuple11 @x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x12
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x13
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x17
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x18
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x19
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x20
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x21
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x22
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22)
(FStar.Pervasives.Native.tuple11 @x23
@x24
@x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple11))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple11))

; </end encoding FStar.Pervasives.Native.Mktuple11>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,5-110,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple11 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
(and (is-FStar.Pervasives.Native.Mktuple11 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple11__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple11__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple11__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple11__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple11__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple11__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple11__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple11__h @x1))
(= @x10
(FStar.Pervasives.Native.Mktuple11__i @x1))
(= @x11
(FStar.Pervasives.Native.Mktuple11__j @x1))
(= @x12
(FStar.Pervasives.Native.Mktuple11__k @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple11 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple11))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple11))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple11__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple11__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple11__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7))
(Valid (Prims.hasEq @x8))
(Valid (Prims.hasEq @x9))
(Valid (Prims.hasEq @x10)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
:qid assumption_FStar.Pervasives.Native.tuple11__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple11__uu___haseq))

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


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> Prims.bool
(declare-fun Tm_arrow_005819ee7a23a5c47189bae72b85d85c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_005819ee7a23a5c47189bae72b85d85c
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_005819ee7a23a5c47189bae72b85d85c
Tm_type)
:named kinding_Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_005819ee7a23a5c47189bae72b85d85c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_005819ee7a23a5c47189bae72b85d85c)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.9))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.10))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.11))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c.12))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_005819ee7a23a5c47189bae72b85d85c))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple11@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.uu___is_Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple11))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple11))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple11@tok
Tm_arrow_005819ee7a23a5c47189bae72b85d85c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple11@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.uu___is_Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple11.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple11@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple11))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple11))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple11))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple11))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(111,4-111,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(BoxBool (is-FStar.Pervasives.Native.Mktuple11 @x11)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid disc_equation_FStar.Pervasives.Native.Mktuple11))

:named disc_equation_FStar.Pervasives.Native.Mktuple11))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple11>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple11/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'a
(declare-fun Tm_arrow_31968e334e9582d95281307f534992a9 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_31968e334e9582d95281307f534992a9
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_31968e334e9582d95281307f534992a9
Tm_type)
:named kinding_Tm_arrow_31968e334e9582d95281307f534992a9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_31968e334e9582d95281307f534992a9)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_31968e334e9582d95281307f534992a9))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_31968e334e9582d95281307f534992a9))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_31968e334e9582d95281307f534992a9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_31968e334e9582d95281307f534992a9
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_31968e334e9582d95281307f534992a9)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,13-110,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_31968e334e9582d95281307f534992a9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_31968e334e9582d95281307f534992a9))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok
Tm_arrow_31968e334e9582d95281307f534992a9))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(112,6-112,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__1 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'b
(declare-fun Tm_arrow_6252dd9f4473dc54a3482810e8556404 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6252dd9f4473dc54a3482810e8556404
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_6252dd9f4473dc54a3482810e8556404
Tm_type)
:named kinding_Tm_arrow_6252dd9f4473dc54a3482810e8556404))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6252dd9f4473dc54a3482810e8556404)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6252dd9f4473dc54a3482810e8556404))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_6252dd9f4473dc54a3482810e8556404))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_6252dd9f4473dc54a3482810e8556404))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6252dd9f4473dc54a3482810e8556404)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,16-110,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6252dd9f4473dc54a3482810e8556404))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_6252dd9f4473dc54a3482810e8556404))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok
Tm_arrow_6252dd9f4473dc54a3482810e8556404))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(113,6-113,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__2 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'c
(declare-fun Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02
Tm_type)
:named kinding_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,19-110,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok
Tm_arrow_ec3ce6b7406c091cd7d0961922bb5a02))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(114,6-114,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__3 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'd
(declare-fun Tm_arrow_be7571e73b0e7fc24d03efe0e003c054 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_be7571e73b0e7fc24d03efe0e003c054
Tm_type)
:named kinding_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_be7571e73b0e7fc24d03efe0e003c054)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_be7571e73b0e7fc24d03efe0e003c054)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,22-110,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok
Tm_arrow_be7571e73b0e7fc24d03efe0e003c054))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(115,6-115,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__4 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'e
(declare-fun Tm_arrow_97ae7d913e508c46c48c3b51553d4459 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_97ae7d913e508c46c48c3b51553d4459
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_97ae7d913e508c46c48c3b51553d4459
Tm_type)
:named kinding_Tm_arrow_97ae7d913e508c46c48c3b51553d4459))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_97ae7d913e508c46c48c3b51553d4459)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_97ae7d913e508c46c48c3b51553d4459))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_97ae7d913e508c46c48c3b51553d4459))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_97ae7d913e508c46c48c3b51553d4459))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_97ae7d913e508c46c48c3b51553d4459)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,25-110,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_97ae7d913e508c46c48c3b51553d4459))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_97ae7d913e508c46c48c3b51553d4459))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok
Tm_arrow_97ae7d913e508c46c48c3b51553d4459))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(116,6-116,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__5 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'f
(declare-fun Tm_arrow_1dca311798936510e0ead61e14cf32a6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1dca311798936510e0ead61e14cf32a6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1dca311798936510e0ead61e14cf32a6
Tm_type)
:named kinding_Tm_arrow_1dca311798936510e0ead61e14cf32a6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1dca311798936510e0ead61e14cf32a6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1dca311798936510e0ead61e14cf32a6))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1dca311798936510e0ead61e14cf32a6))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1dca311798936510e0ead61e14cf32a6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1dca311798936510e0ead61e14cf32a6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,28-110,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1dca311798936510e0ead61e14cf32a6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1dca311798936510e0ead61e14cf32a6))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok
Tm_arrow_1dca311798936510e0ead61e14cf32a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(117,6-117,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__6 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'g
(declare-fun Tm_arrow_eec431ea31093a646681ef2ceb2e2986 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_eec431ea31093a646681ef2ceb2e2986
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_eec431ea31093a646681ef2ceb2e2986
Tm_type)
:named kinding_Tm_arrow_eec431ea31093a646681ef2ceb2e2986))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_eec431ea31093a646681ef2ceb2e2986)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_eec431ea31093a646681ef2ceb2e2986))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_eec431ea31093a646681ef2ceb2e2986))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_eec431ea31093a646681ef2ceb2e2986))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_eec431ea31093a646681ef2ceb2e2986)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,31-110,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_eec431ea31093a646681ef2ceb2e2986))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_eec431ea31093a646681ef2ceb2e2986))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok
Tm_arrow_eec431ea31093a646681ef2ceb2e2986))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(118,6-118,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__7 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'h
(declare-fun Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6
Tm_type)
:named kinding_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,34-110,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok
Tm_arrow_689b2f06e9fd83f7a84ce80a13d338c6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(119,6-119,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__8 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'i
(declare-fun Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf
Tm_type)
:named kinding_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,37-110,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___9))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok
Tm_arrow_20210a3d9498f929cb7aa68d9e8b5ebf))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___9@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___9))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___9))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___9))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(120,6-120,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__9 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__9))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__9))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___9>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___9/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'j
(declare-fun Tm_arrow_96812f2124d88760b2002bbe1502c3c9 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_96812f2124d88760b2002bbe1502c3c9
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_96812f2124d88760b2002bbe1502c3c9
Tm_type)
:named kinding_Tm_arrow_96812f2124d88760b2002bbe1502c3c9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_96812f2124d88760b2002bbe1502c3c9)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_96812f2124d88760b2002bbe1502c3c9))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_96812f2124d88760b2002bbe1502c3c9))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_96812f2124d88760b2002bbe1502c3c9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_96812f2124d88760b2002bbe1502c3c9)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,40-110,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_96812f2124d88760b2002bbe1502c3c9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_96812f2124d88760b2002bbe1502c3c9))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___10))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___10))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok
Tm_arrow_96812f2124d88760b2002bbe1502c3c9))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___10.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___10@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___10))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___10))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___10))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___10))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(121,6-121,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__10 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__10))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__10))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___10>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___10/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) -> 'k
(declare-fun Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d
Tm_type)
:named kinding_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(110,43-110,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d.12))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___11))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple11__item___11))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok
Tm_arrow_abcfa2582f68905d460c5ef4a7642f2d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___11.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple11__item___11@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___11))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple11__item___11))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
(FStar.Pervasives.Native.tuple11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple11__item___11))

:named typing_FStar.Pervasives.Native.__proj__Mktuple11__item___11))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple11__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(122,6-122,9)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
(FStar.Pervasives.Native.Mktuple11__11 @x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple11__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid proj_equation_FStar.Pervasives.Native.Mktuple11__11))

:named proj_equation_FStar.Pervasives.Native.Mktuple11__11))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple11__item___11>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple11__item___11/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple12 (Term Term Term Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x7 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x8 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x9 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x10 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple12@x11 (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: Mktuple12
(declare-fun FStar.Pervasives.Native.Mktuple12@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a ->     _2: 'b ->     _3: 'c ->     _4: 'd ->     _5: 'e ->     _6: 'f ->     _7: 'g ->     _8: 'h ->     _9: 'i ->     _10: 'j ->     _11: 'k ->     _12: 'l   -> (((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l
(declare-fun Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65
Tm_type)
:named kinding_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6)
(HasType @x19
@x7)
(HasType @x20
@x8)
(HasType @x21
@x9)
(HasType @x22
@x10)
(HasType @x23
@x11)
(HasType @x24
@x12))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.16))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.17))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.18))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.19))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6)
(HasType @x19
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.20))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6)
(HasType @x19
@x7)
(HasType @x20
@x8))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.21))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6)
(HasType @x19
@x7)
(HasType @x20
@x8)
(HasType @x21
@x9))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.22))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6)
(HasType @x19
@x7)
(HasType @x20
@x8)
(HasType @x21
@x9)
(HasType @x22
@x10))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.23))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(139,7-139,50)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
@x1)
(HasType @x14
@x2)
(HasType @x15
@x3)
(HasType @x16
@x4)
(HasType @x17
@x5)
(HasType @x18
@x6)
(HasType @x19
@x7)
(HasType @x20
@x8)
(HasType @x21
@x9)
(HasType @x22
@x10)
(HasType @x23
@x11))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65.24))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))

; <Start encoding FStar.Pervasives.Native.tuple12>


; <start constructor FStar.Pervasives.Native.tuple12>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= 389
(Term_constr_id (FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
 

:pattern ((FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid constructor_distinct_FStar.Pervasives.Native.tuple12))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple12))))

; </end constructor FStar.Pervasives.Native.tuple12>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (= 390
(Term_constr_id FStar.Pervasives.Native.tuple12@tok))
:named fresh_token_FStar.Pervasives.Native.tuple12@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))

:pattern ((FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid token_correspondence_FStar.Pervasives.Native.tuple12@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple12@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple12@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple12@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple12@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple12@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(HasType (FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))
:qid kinding_FStar.Pervasives.Native.tuple12@tok.11))
)
:named kinding_FStar.Pervasives.Native.tuple12@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple12 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
(= (FStar.Pervasives.Native.tuple12 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple12 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
:qid FStar.Pervasives.Native_pretyping_f9e410530ed8c09b547ce586b98a2bfb))

:named FStar.Pervasives.Native_pretyping_f9e410530ed8c09b547ce586b98a2bfb))

; </end encoding FStar.Pervasives.Native.tuple12>


; <Start encoding FStar.Pervasives.Native.Mktuple12>


; <start constructor FStar.Pervasives.Native.Mktuple12>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= 396
(Term_constr_id (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23)))
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple12))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple12))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__a (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__b (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__c (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__d (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__e (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__f (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__g (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__h (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__i (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__i))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__i))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__j (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__j))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__j))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__k (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__k))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__k))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__l (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__l))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__l))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__1 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__2 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__3 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__4 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__5 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x16)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__6 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x17)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__7 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x18)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__8 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x19)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__9 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x20)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__9))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__9))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__10 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x21)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__10))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__10))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__11 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x22)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__11))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__11))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (FStar.Pervasives.Native.Mktuple12__12 (FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
@x23)
 

:pattern ((FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple12__12))

:named projection_inverse_FStar.Pervasives.Native.Mktuple12__12))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (= 399
(Term_constr_id FStar.Pervasives.Native.Mktuple12@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple12@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple12@tok
Tm_arrow_4d5cd995d6f44a2ec39d0f193be0be65))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple12@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple12@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple12@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple12@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
(FStar.Pervasives.Native.Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23))
:qid equality_tok_FStar.Pervasives.Native.Mktuple12@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple12@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x13
@x1)
(HasTypeFuel @u0
@x14
@x2)
(HasTypeFuel @u0
@x15
@x3)
(HasTypeFuel @u0
@x16
@x4)
(HasTypeFuel @u0
@x17
@x5)
(HasTypeFuel @u0
@x18
@x6)
(HasTypeFuel @u0
@x19
@x7)
(HasTypeFuel @u0
@x20
@x8)
(HasTypeFuel @u0
@x21
@x9)
(HasTypeFuel @u0
@x22
@x10)
(HasTypeFuel @u0
@x23
@x11)
(HasTypeFuel @u0
@x24
@x12))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple12@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple12@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term) (@x34 Term) (@x35 Term) (@x36 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)
(FStar.Pervasives.Native.tuple12 @x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36))
(and (HasTypeFuel @u0
@x36
Tm_type)
(HasTypeFuel @u0
@x24
@x36)
(HasTypeFuel @u0
@x35
Tm_type)
(HasTypeFuel @u0
@x23
@x35)
(HasTypeFuel @u0
@x34
Tm_type)
(HasTypeFuel @u0
@x22
@x34)
(HasTypeFuel @u0
@x33
Tm_type)
(HasTypeFuel @u0
@x21
@x33)
(HasTypeFuel @u0
@x32
Tm_type)
(HasTypeFuel @u0
@x20
@x32)
(HasTypeFuel @u0
@x31
Tm_type)
(HasTypeFuel @u0
@x19
@x31)
(HasTypeFuel @u0
@x30
Tm_type)
(HasTypeFuel @u0
@x18
@x30)
(HasTypeFuel @u0
@x29
Tm_type)
(HasTypeFuel @u0
@x17
@x29)
(HasTypeFuel @u0
@x28
Tm_type)
(HasTypeFuel @u0
@x16
@x28)
(HasTypeFuel @u0
@x27
Tm_type)
(HasTypeFuel @u0
@x15
@x27)
(HasTypeFuel @u0
@x26
Tm_type)
(HasTypeFuel @u0
@x14
@x26)
(HasTypeFuel @u0
@x25
Tm_type)
(HasTypeFuel @u0
@x13
@x25)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x13
@x1)
(HasTypeFuel @u0
@x14
@x2)
(HasTypeFuel @u0
@x15
@x3)
(HasTypeFuel @u0
@x16
@x4)
(HasTypeFuel @u0
@x17
@x5)
(HasTypeFuel @u0
@x18
@x6)
(HasTypeFuel @u0
@x19
@x7)
(HasTypeFuel @u0
@x20
@x8)
(HasTypeFuel @u0
@x21
@x9)
(HasTypeFuel @u0
@x22
@x10)
(HasTypeFuel @u0
@x23
@x11)
(HasTypeFuel @u0
@x24
@x12)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)
(FStar.Pervasives.Native.tuple12 @x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36)))
:qid data_elim_FStar.Pervasives.Native.Mktuple12))

:named data_elim_FStar.Pervasives.Native.Mktuple12))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term) (@x34 Term) (@x35 Term) (@x36 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)
(FStar.Pervasives.Native.tuple12 @x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x13
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x17
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x18
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x19
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x20
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x21
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x22
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x23
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x24
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24)
(FStar.Pervasives.Native.tuple12 @x25
@x26
@x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple12))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple12))

; </end encoding FStar.Pervasives.Native.Mktuple12>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,5-125,12)
(forall ((@u0 Fuel) (@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))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple12 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
(and (is-FStar.Pervasives.Native.Mktuple12 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple12__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple12__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple12__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple12__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple12__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple12__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple12__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple12__h @x1))
(= @x10
(FStar.Pervasives.Native.Mktuple12__i @x1))
(= @x11
(FStar.Pervasives.Native.Mktuple12__j @x1))
(= @x12
(FStar.Pervasives.Native.Mktuple12__k @x1))
(= @x13
(FStar.Pervasives.Native.Mktuple12__l @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple12 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple12))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple12))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple12__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple12__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple12__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7))
(Valid (Prims.hasEq @x8))
(Valid (Prims.hasEq @x9))
(Valid (Prims.hasEq @x10))
(Valid (Prims.hasEq @x11)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
:qid assumption_FStar.Pervasives.Native.tuple12__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple12__uu___haseq))

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


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l)   -> Prims.bool
(declare-fun Tm_arrow_5c9f47d9090f554c9826d2f65e388f20 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_5c9f47d9090f554c9826d2f65e388f20
Tm_type)
:named kinding_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5c9f47d9090f554c9826d2f65e388f20)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5c9f47d9090f554c9826d2f65e388f20)
(and (forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.9))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.10))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.11))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.12))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20.13))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple12@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.uu___is_Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple12))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple12))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple12@tok
Tm_arrow_5c9f47d9090f554c9826d2f65e388f20))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple12@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.uu___is_Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple12.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple12@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple12))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple12))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple12))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple12))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(126,4-126,13)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(BoxBool (is-FStar.Pervasives.Native.Mktuple12 @x12)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid disc_equation_FStar.Pervasives.Native.Mktuple12))

:named disc_equation_FStar.Pervasives.Native.Mktuple12))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple12>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple12/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'a
(declare-fun Tm_arrow_618941d7cf5ddbaabe15df8579b4a387 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_618941d7cf5ddbaabe15df8579b4a387
Tm_type)
:named kinding_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_618941d7cf5ddbaabe15df8579b4a387)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_618941d7cf5ddbaabe15df8579b4a387)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,13-125,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok
Tm_arrow_618941d7cf5ddbaabe15df8579b4a387))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(127,6-127,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__1 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'b
(declare-fun Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6
Tm_type)
:named kinding_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,16-125,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok
Tm_arrow_84e9e2280e9bcb3233e4f33f86d66ea6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(128,6-128,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__2 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'c
(declare-fun Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa
Tm_type)
:named kinding_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,19-125,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok
Tm_arrow_1fa79c5abf9f18607bd2e46a1a6967fa))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(129,6-129,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__3 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'd
(declare-fun Tm_arrow_0f49c582489d782b08195e81221181dc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0f49c582489d782b08195e81221181dc
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_0f49c582489d782b08195e81221181dc
Tm_type)
:named kinding_Tm_arrow_0f49c582489d782b08195e81221181dc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_0f49c582489d782b08195e81221181dc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_0f49c582489d782b08195e81221181dc))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_0f49c582489d782b08195e81221181dc))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_0f49c582489d782b08195e81221181dc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_0f49c582489d782b08195e81221181dc)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,22-125,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_0f49c582489d782b08195e81221181dc))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_0f49c582489d782b08195e81221181dc))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok
Tm_arrow_0f49c582489d782b08195e81221181dc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(130,6-130,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__4 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'e
(declare-fun Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a
Tm_type)
:named kinding_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,25-125,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok
Tm_arrow_29b7181ebb44f9e4a45f95c4f8478c6a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(131,6-131,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__5 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'f
(declare-fun Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90
Tm_type)
:named kinding_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,28-125,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok
Tm_arrow_3cc2863a7d7f23e3916fa1e43483cb90))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(132,6-132,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__6 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'g
(declare-fun Tm_arrow_c7deea49701ab64a73985bf522e46359 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c7deea49701ab64a73985bf522e46359
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_c7deea49701ab64a73985bf522e46359
Tm_type)
:named kinding_Tm_arrow_c7deea49701ab64a73985bf522e46359))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c7deea49701ab64a73985bf522e46359)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c7deea49701ab64a73985bf522e46359))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_c7deea49701ab64a73985bf522e46359))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_c7deea49701ab64a73985bf522e46359))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c7deea49701ab64a73985bf522e46359)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,31-125,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c7deea49701ab64a73985bf522e46359))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_c7deea49701ab64a73985bf522e46359))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok
Tm_arrow_c7deea49701ab64a73985bf522e46359))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(133,6-133,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__7 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'h
(declare-fun Tm_arrow_380615e7761919086537a14273a02d22 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_380615e7761919086537a14273a02d22
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_380615e7761919086537a14273a02d22
Tm_type)
:named kinding_Tm_arrow_380615e7761919086537a14273a02d22))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_380615e7761919086537a14273a02d22)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_380615e7761919086537a14273a02d22))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_380615e7761919086537a14273a02d22))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_380615e7761919086537a14273a02d22))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_380615e7761919086537a14273a02d22
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_380615e7761919086537a14273a02d22)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,34-125,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_380615e7761919086537a14273a02d22))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_380615e7761919086537a14273a02d22))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok
Tm_arrow_380615e7761919086537a14273a02d22))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(134,6-134,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__8 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'i
(declare-fun Tm_arrow_245250918a4432b31aea8152d056489a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_245250918a4432b31aea8152d056489a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_245250918a4432b31aea8152d056489a
Tm_type)
:named kinding_Tm_arrow_245250918a4432b31aea8152d056489a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_245250918a4432b31aea8152d056489a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_245250918a4432b31aea8152d056489a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_245250918a4432b31aea8152d056489a))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_245250918a4432b31aea8152d056489a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_245250918a4432b31aea8152d056489a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_245250918a4432b31aea8152d056489a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,37-125,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_245250918a4432b31aea8152d056489a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_245250918a4432b31aea8152d056489a))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___9))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok
Tm_arrow_245250918a4432b31aea8152d056489a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___9@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___9))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___9))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___9))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(135,6-135,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__9 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__9))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__9))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___9>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___9/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'j
(declare-fun Tm_arrow_2a967c8402c441e6d8a9336a7568e4de () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_2a967c8402c441e6d8a9336a7568e4de
Tm_type)
:named kinding_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2a967c8402c441e6d8a9336a7568e4de)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2a967c8402c441e6d8a9336a7568e4de)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,40-125,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___10))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___10))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok
Tm_arrow_2a967c8402c441e6d8a9336a7568e4de))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___10.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___10@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___10))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___10))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___10))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___10))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(136,6-136,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__10 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__10))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__10))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___10>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___10/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'k
(declare-fun Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964
Tm_type)
:named kinding_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,43-125,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___11))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___11))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok
Tm_arrow_543c3feac0cd9e04ecb6cfd74ced8964))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___11.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___11@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___11))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___11))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___11))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___11))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(137,6-137,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__11 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__11))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__11))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___11>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___11/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) -> 'l
(declare-fun Tm_arrow_e91029e2320896c60e94f554727a0c41 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e91029e2320896c60e94f554727a0c41
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_e91029e2320896c60e94f554727a0c41
Tm_type)
:named kinding_Tm_arrow_e91029e2320896c60e94f554727a0c41))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e91029e2320896c60e94f554727a0c41)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e91029e2320896c60e94f554727a0c41))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_e91029e2320896c60e94f554727a0c41))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_e91029e2320896c60e94f554727a0c41))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e91029e2320896c60e94f554727a0c41)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(125,46-125,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41.13))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e91029e2320896c60e94f554727a0c41))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_e91029e2320896c60e94f554727a0c41))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___12))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple12__item___12))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok
Tm_arrow_e91029e2320896c60e94f554727a0c41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___12.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple12__item___12@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___12))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple12__item___12))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
(FStar.Pervasives.Native.tuple12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple12__item___12))

:named typing_FStar.Pervasives.Native.__proj__Mktuple12__item___12))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple12__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(138,6-138,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
(FStar.Pervasives.Native.Mktuple12__12 @x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple12__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid proj_equation_FStar.Pervasives.Native.Mktuple12__12))

:named proj_equation_FStar.Pervasives.Native.Mktuple12__12))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple12__item___12>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple12__item___12/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple13 (Term Term Term Term Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x7 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x8 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x9 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x10 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x11 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple13@x12 (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: Mktuple13
(declare-fun FStar.Pervasives.Native.Mktuple13@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a ->     _2: 'b ->     _3: 'c ->     _4: 'd ->     _5: 'e ->     _6: 'f ->     _7: 'g ->     _8: 'h ->     _9: 'i ->     _10: 'j ->     _11: 'k ->     _12: 'l ->     _13: 'm   -> ((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm
(declare-fun Tm_arrow_6462785e86ca440ee74ed32e1053eae3 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6462785e86ca440ee74ed32e1053eae3
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_6462785e86ca440ee74ed32e1053eae3
Tm_type)
:named kinding_Tm_arrow_6462785e86ca440ee74ed32e1053eae3))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6462785e86ca440ee74ed32e1053eae3)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6462785e86ca440ee74ed32e1053eae3))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_6462785e86ca440ee74ed32e1053eae3))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_6462785e86ca440ee74ed32e1053eae3))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6462785e86ca440ee74ed32e1053eae3)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7)
(HasType @x21
@x8)
(HasType @x22
@x9)
(HasType @x23
@x10)
(HasType @x24
@x11)
(HasType @x25
@x12)
(HasType @x26
@x13))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.16))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.17))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.18))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.19))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.20))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.21))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7)
(HasType @x21
@x8))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.22))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7)
(HasType @x21
@x8)
(HasType @x22
@x9))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.23))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7)
(HasType @x21
@x8)
(HasType @x22
@x9)
(HasType @x23
@x10))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.24))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7)
(HasType @x21
@x8)
(HasType @x22
@x9)
(HasType @x23
@x10)
(HasType @x24
@x11))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.25))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(156,7-156,53)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
@x1)
(HasType @x15
@x2)
(HasType @x16
@x3)
(HasType @x17
@x4)
(HasType @x18
@x5)
(HasType @x19
@x6)
(HasType @x20
@x7)
(HasType @x21
@x8)
(HasType @x22
@x9)
(HasType @x23
@x10)
(HasType @x24
@x11)
(HasType @x25
@x12))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3.26))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6462785e86ca440ee74ed32e1053eae3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_6462785e86ca440ee74ed32e1053eae3))

; <Start encoding FStar.Pervasives.Native.tuple13>


; <start constructor FStar.Pervasives.Native.tuple13>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@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))
 (! (= 426
(Term_constr_id (FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
 

:pattern ((FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid constructor_distinct_FStar.Pervasives.Native.tuple13))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple13))))

; </end constructor FStar.Pervasives.Native.tuple13>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (= 427
(Term_constr_id FStar.Pervasives.Native.tuple13@tok))
:named fresh_token_FStar.Pervasives.Native.tuple13@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))

:pattern ((FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid token_correspondence_FStar.Pervasives.Native.tuple13@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple13@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple13@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple13@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple13@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple13@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(HasType (FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))
:qid kinding_FStar.Pervasives.Native.tuple13@tok.12))
)
:named kinding_FStar.Pervasives.Native.tuple13@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple13 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
(= (FStar.Pervasives.Native.tuple13 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple13 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
:qid FStar.Pervasives.Native_pretyping_17418c432657cdd1e355c73a5a484479))

:named FStar.Pervasives.Native_pretyping_17418c432657cdd1e355c73a5a484479))

; </end encoding FStar.Pervasives.Native.tuple13>


; <Start encoding FStar.Pervasives.Native.Mktuple13>


; <start constructor FStar.Pervasives.Native.Mktuple13>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= 433
(Term_constr_id (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25)))
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple13))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple13))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__a (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__b (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__c (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__d (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__e (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__f (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__g (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__h (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__i (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__i))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__i))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__j (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__j))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__j))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__k (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__k))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__k))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__l (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__l))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__l))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__m (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__m))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__m))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__1 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__2 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__3 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__4 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x16)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__5 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x17)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__6 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x18)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__7 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x19)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__8 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x20)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__9 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x21)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__9))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__9))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__10 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x22)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__10))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__10))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__11 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x23)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__11))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__11))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__12 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x24)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__12))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__12))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (FStar.Pervasives.Native.Mktuple13__13 (FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
@x25)
 

:pattern ((FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple13__13))

:named projection_inverse_FStar.Pervasives.Native.Mktuple13__13))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (= 436
(Term_constr_id FStar.Pervasives.Native.Mktuple13@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple13@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple13@tok
Tm_arrow_6462785e86ca440ee74ed32e1053eae3))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple13@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple13@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple13@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple13@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
(FStar.Pervasives.Native.Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25))
:qid equality_tok_FStar.Pervasives.Native.Mktuple13@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple13@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x13
Tm_type)
(HasTypeFuel @u0
@x14
@x1)
(HasTypeFuel @u0
@x15
@x2)
(HasTypeFuel @u0
@x16
@x3)
(HasTypeFuel @u0
@x17
@x4)
(HasTypeFuel @u0
@x18
@x5)
(HasTypeFuel @u0
@x19
@x6)
(HasTypeFuel @u0
@x20
@x7)
(HasTypeFuel @u0
@x21
@x8)
(HasTypeFuel @u0
@x22
@x9)
(HasTypeFuel @u0
@x23
@x10)
(HasTypeFuel @u0
@x24
@x11)
(HasTypeFuel @u0
@x25
@x12)
(HasTypeFuel @u0
@x26
@x13))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple13@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple13@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term) (@x34 Term) (@x35 Term) (@x36 Term) (@x37 Term) (@x38 Term) (@x39 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)
(FStar.Pervasives.Native.tuple13 @x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39))
(and (HasTypeFuel @u0
@x39
Tm_type)
(HasTypeFuel @u0
@x26
@x39)
(HasTypeFuel @u0
@x38
Tm_type)
(HasTypeFuel @u0
@x25
@x38)
(HasTypeFuel @u0
@x37
Tm_type)
(HasTypeFuel @u0
@x24
@x37)
(HasTypeFuel @u0
@x36
Tm_type)
(HasTypeFuel @u0
@x23
@x36)
(HasTypeFuel @u0
@x35
Tm_type)
(HasTypeFuel @u0
@x22
@x35)
(HasTypeFuel @u0
@x34
Tm_type)
(HasTypeFuel @u0
@x21
@x34)
(HasTypeFuel @u0
@x33
Tm_type)
(HasTypeFuel @u0
@x20
@x33)
(HasTypeFuel @u0
@x32
Tm_type)
(HasTypeFuel @u0
@x19
@x32)
(HasTypeFuel @u0
@x31
Tm_type)
(HasTypeFuel @u0
@x18
@x31)
(HasTypeFuel @u0
@x30
Tm_type)
(HasTypeFuel @u0
@x17
@x30)
(HasTypeFuel @u0
@x29
Tm_type)
(HasTypeFuel @u0
@x16
@x29)
(HasTypeFuel @u0
@x28
Tm_type)
(HasTypeFuel @u0
@x15
@x28)
(HasTypeFuel @u0
@x27
Tm_type)
(HasTypeFuel @u0
@x14
@x27)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x13
Tm_type)
(HasTypeFuel @u0
@x14
@x1)
(HasTypeFuel @u0
@x15
@x2)
(HasTypeFuel @u0
@x16
@x3)
(HasTypeFuel @u0
@x17
@x4)
(HasTypeFuel @u0
@x18
@x5)
(HasTypeFuel @u0
@x19
@x6)
(HasTypeFuel @u0
@x20
@x7)
(HasTypeFuel @u0
@x21
@x8)
(HasTypeFuel @u0
@x22
@x9)
(HasTypeFuel @u0
@x23
@x10)
(HasTypeFuel @u0
@x24
@x11)
(HasTypeFuel @u0
@x25
@x12)
(HasTypeFuel @u0
@x26
@x13)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)
(FStar.Pervasives.Native.tuple13 @x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39)))
:qid data_elim_FStar.Pervasives.Native.Mktuple13))

:named data_elim_FStar.Pervasives.Native.Mktuple13))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term) (@x34 Term) (@x35 Term) (@x36 Term) (@x37 Term) (@x38 Term) (@x39 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)
(FStar.Pervasives.Native.tuple13 @x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x14
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x17
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x18
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x19
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x20
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x21
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x22
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x23
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x24
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x25
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x26
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26)
(FStar.Pervasives.Native.tuple13 @x27
@x28
@x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple13))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple13))

; </end encoding FStar.Pervasives.Native.Mktuple13>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,5-141,12)
(forall ((@u0 Fuel) (@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) (@x14 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple13 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
(and (is-FStar.Pervasives.Native.Mktuple13 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple13__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple13__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple13__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple13__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple13__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple13__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple13__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple13__h @x1))
(= @x10
(FStar.Pervasives.Native.Mktuple13__i @x1))
(= @x11
(FStar.Pervasives.Native.Mktuple13__j @x1))
(= @x12
(FStar.Pervasives.Native.Mktuple13__k @x1))
(= @x13
(FStar.Pervasives.Native.Mktuple13__l @x1))
(= @x14
(FStar.Pervasives.Native.Mktuple13__m @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple13 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple13))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple13))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple13__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple13__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple13__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7))
(Valid (Prims.hasEq @x8))
(Valid (Prims.hasEq @x9))
(Valid (Prims.hasEq @x10))
(Valid (Prims.hasEq @x11))
(Valid (Prims.hasEq @x12)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
:qid assumption_FStar.Pervasives.Native.tuple13__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple13__uu___haseq))

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


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> Prims.bool
(declare-fun Tm_arrow_68c092e8b387730b412c4dcf592b12d3 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_68c092e8b387730b412c4dcf592b12d3
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_68c092e8b387730b412c4dcf592b12d3
Tm_type)
:named kinding_Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_68c092e8b387730b412c4dcf592b12d3)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_68c092e8b387730b412c4dcf592b12d3)
(and (forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.9))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.10))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.11))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.12))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.13))
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3.14))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_68c092e8b387730b412c4dcf592b12d3))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple13@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.uu___is_Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple13))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple13))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple13@tok
Tm_arrow_68c092e8b387730b412c4dcf592b12d3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple13@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.uu___is_Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple13.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple13@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple13))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple13))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple13))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple13))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(142,4-142,13)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(BoxBool (is-FStar.Pervasives.Native.Mktuple13 @x13)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid disc_equation_FStar.Pervasives.Native.Mktuple13))

:named disc_equation_FStar.Pervasives.Native.Mktuple13))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple13>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple13/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'a
(declare-fun Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f
Tm_type)
:named kinding_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,13-141,15)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok
Tm_arrow_82a3dc3a5dbad615d8d4a31db238e43f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(143,6-143,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__1 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'b
(declare-fun Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306
Tm_type)
:named kinding_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,16-141,18)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok
Tm_arrow_1da976aaa65f1c6b8b256dfc45c41306))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(144,6-144,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__2 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'c
(declare-fun Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f
Tm_type)
:named kinding_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,19-141,21)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok
Tm_arrow_ca5cf529c415deee29e0a34c0c5d1c9f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(145,6-145,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__3 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'd
(declare-fun Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b
Tm_type)
:named kinding_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,22-141,24)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok
Tm_arrow_94f6c578541b6cb528ca9e7dd1dacc3b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(146,6-146,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__4 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'e
(declare-fun Tm_arrow_211e172b7220adc186d8a02ff17e8780 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_211e172b7220adc186d8a02ff17e8780
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_211e172b7220adc186d8a02ff17e8780
Tm_type)
:named kinding_Tm_arrow_211e172b7220adc186d8a02ff17e8780))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_211e172b7220adc186d8a02ff17e8780)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_211e172b7220adc186d8a02ff17e8780))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_211e172b7220adc186d8a02ff17e8780))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_211e172b7220adc186d8a02ff17e8780))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_211e172b7220adc186d8a02ff17e8780)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,25-141,27)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_211e172b7220adc186d8a02ff17e8780))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_211e172b7220adc186d8a02ff17e8780))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok
Tm_arrow_211e172b7220adc186d8a02ff17e8780))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(147,6-147,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__5 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'f
(declare-fun Tm_arrow_9276a4f669d8497205e8d59f12da53ba () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9276a4f669d8497205e8d59f12da53ba
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9276a4f669d8497205e8d59f12da53ba
Tm_type)
:named kinding_Tm_arrow_9276a4f669d8497205e8d59f12da53ba))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9276a4f669d8497205e8d59f12da53ba)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9276a4f669d8497205e8d59f12da53ba))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9276a4f669d8497205e8d59f12da53ba))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9276a4f669d8497205e8d59f12da53ba))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9276a4f669d8497205e8d59f12da53ba)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,28-141,30)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9276a4f669d8497205e8d59f12da53ba))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9276a4f669d8497205e8d59f12da53ba))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok
Tm_arrow_9276a4f669d8497205e8d59f12da53ba))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(148,6-148,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__6 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'g
(declare-fun Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f
Tm_type)
:named kinding_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,31-141,33)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok
Tm_arrow_8aa8f381a5ed57cbbae9dcd2405ce80f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(149,6-149,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__7 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'h
(declare-fun Tm_arrow_51814106613688cf259d7cdba9c24d93 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_51814106613688cf259d7cdba9c24d93
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_51814106613688cf259d7cdba9c24d93
Tm_type)
:named kinding_Tm_arrow_51814106613688cf259d7cdba9c24d93))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_51814106613688cf259d7cdba9c24d93)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_51814106613688cf259d7cdba9c24d93))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_51814106613688cf259d7cdba9c24d93))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_51814106613688cf259d7cdba9c24d93))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_51814106613688cf259d7cdba9c24d93)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,34-141,36)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_51814106613688cf259d7cdba9c24d93))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_51814106613688cf259d7cdba9c24d93))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok
Tm_arrow_51814106613688cf259d7cdba9c24d93))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(150,6-150,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__8 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'i
(declare-fun Tm_arrow_05fec25e6f03f974bb2933a910642d7e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_05fec25e6f03f974bb2933a910642d7e
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_05fec25e6f03f974bb2933a910642d7e
Tm_type)
:named kinding_Tm_arrow_05fec25e6f03f974bb2933a910642d7e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_05fec25e6f03f974bb2933a910642d7e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_05fec25e6f03f974bb2933a910642d7e))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_05fec25e6f03f974bb2933a910642d7e))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_05fec25e6f03f974bb2933a910642d7e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_05fec25e6f03f974bb2933a910642d7e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,37-141,39)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_05fec25e6f03f974bb2933a910642d7e))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_05fec25e6f03f974bb2933a910642d7e))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___9))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok
Tm_arrow_05fec25e6f03f974bb2933a910642d7e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___9@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___9))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___9))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___9))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(151,6-151,8)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__9 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__9))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__9))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___9>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___9/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'j
(declare-fun Tm_arrow_3280ee04611a7985c9d107bb1a8a330a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_3280ee04611a7985c9d107bb1a8a330a
Tm_type)
:named kinding_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3280ee04611a7985c9d107bb1a8a330a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3280ee04611a7985c9d107bb1a8a330a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,40-141,42)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___10))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___10))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok
Tm_arrow_3280ee04611a7985c9d107bb1a8a330a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___10.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___10@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___10))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___10))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___10))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___10))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(152,6-152,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__10 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__10))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__10))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___10>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___10/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'k
(declare-fun Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90
Tm_type)
:named kinding_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,43-141,45)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___11))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___11))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok
Tm_arrow_86c868d5d5058e8e5ec1f4d0285c7e90))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___11.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___11@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___11))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___11))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___11))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___11))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(153,6-153,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__11 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__11))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__11))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___11>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___11/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'l
(declare-fun Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da
Tm_type)
:named kinding_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,46-141,48)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___12))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___12))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok
Tm_arrow_7263c1a3c4475bb4e4b41a1be4bf22da))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___12.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___12@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___12))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___12))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___12))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___12))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(154,6-154,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__12 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__12))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__12))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___12>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___12/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee: (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm)   -> 'm
(declare-fun Tm_arrow_338c65ae58844787891c6f47cf01c068 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_338c65ae58844787891c6f47cf01c068
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_338c65ae58844787891c6f47cf01c068
Tm_type)
:named kinding_Tm_arrow_338c65ae58844787891c6f47cf01c068))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_338c65ae58844787891c6f47cf01c068)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_338c65ae58844787891c6f47cf01c068))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_338c65ae58844787891c6f47cf01c068))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_338c65ae58844787891c6f47cf01c068))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_338c65ae58844787891c6f47cf01c068)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(141,49-141,51)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068.14))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_338c65ae58844787891c6f47cf01c068))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_338c65ae58844787891c6f47cf01c068))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___13))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple13__item___13))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok
Tm_arrow_338c65ae58844787891c6f47cf01c068))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___13.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple13__item___13@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___13))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple13__item___13))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
(FStar.Pervasives.Native.tuple13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple13__item___13))

:named typing_FStar.Pervasives.Native.__proj__Mktuple13__item___13))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple13__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(155,6-155,9)
(forall ((@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))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
(FStar.Pervasives.Native.Mktuple13__13 @x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple13__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid proj_equation_FStar.Pervasives.Native.Mktuple13__13))

:named proj_equation_FStar.Pervasives.Native.Mktuple13__13))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple13__item___13>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple13__item___13/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Native.tuple14 (Term Term Term Term Term Term Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x3 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x4 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x5 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x6 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x7 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x8 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x9 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x10 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x11 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x12 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Native.tuple14@x13 (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: Mktuple14
(declare-fun FStar.Pervasives.Native.Mktuple14@tok () Term)
;;;;;;;;;;;;;;;;_1: 'a ->     _2: 'b ->     _3: 'c ->     _4: 'd ->     _5: 'e ->     _6: 'f ->     _7: 'g ->     _8: 'h ->     _9: 'i ->     _10: 'j ->     _11: 'k ->     _12: 'l ->     _13: 'm ->     _14: 'n   -> (((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n
(declare-fun Tm_arrow_484e3bf88a886900f7e695d7333615e9 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_484e3bf88a886900f7e695d7333615e9
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_484e3bf88a886900f7e695d7333615e9
Tm_type)
:named kinding_Tm_arrow_484e3bf88a886900f7e695d7333615e9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_484e3bf88a886900f7e695d7333615e9)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_484e3bf88a886900f7e695d7333615e9))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_484e3bf88a886900f7e695d7333615e9))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_484e3bf88a886900f7e695d7333615e9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_484e3bf88a886900f7e695d7333615e9)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8)
(HasType @x23
@x9)
(HasType @x24
@x10)
(HasType @x25
@x11)
(HasType @x26
@x12)
(HasType @x27
@x13)
(HasType @x28
@x14))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
@x27)
@x28)
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
@x27)
@x28))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.15))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.16))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.17))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.18))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.19))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.20))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.21))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.22))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.23))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8)
(HasType @x23
@x9))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.24))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8)
(HasType @x23
@x9)
(HasType @x24
@x10))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.25))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8)
(HasType @x23
@x9)
(HasType @x24
@x10)
(HasType @x25
@x11))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.26))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8)
(HasType @x23
@x9)
(HasType @x24
@x10)
(HasType @x25
@x11)
(HasType @x26
@x12))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.27))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(174,7-174,56)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
@x1)
(HasType @x16
@x2)
(HasType @x17
@x3)
(HasType @x18
@x4)
(HasType @x19
@x5)
(HasType @x20
@x6)
(HasType @x21
@x7)
(HasType @x22
@x8)
(HasType @x23
@x9)
(HasType @x24
@x10)
(HasType @x25
@x11)
(HasType @x26
@x12)
(HasType @x27
@x13))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
@x27)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
@x27))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9.28))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_484e3bf88a886900f7e695d7333615e9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_484e3bf88a886900f7e695d7333615e9))

; <Start encoding FStar.Pervasives.Native.tuple14>


; <start constructor FStar.Pervasives.Native.tuple14>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@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))
 (! (= 465
(Term_constr_id (FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
 

:pattern ((FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid constructor_distinct_FStar.Pervasives.Native.tuple14))

:named constructor_distinct_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))
 
;;no pats
:qid is-FStar.Pervasives.Native.tuple14))))

; </end constructor FStar.Pervasives.Native.tuple14>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (= 466
(Term_constr_id FStar.Pervasives.Native.tuple14@tok))
:named fresh_token_FStar.Pervasives.Native.tuple14@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@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))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))

:pattern ((FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid token_correspondence_FStar.Pervasives.Native.tuple14@tok))

:named token_correspondence_FStar.Pervasives.Native.tuple14@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.Native.tuple14@tok))
:named pre_kinding_FStar.Pervasives.Native.tuple14@tok))
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (and (IsTotFun FStar.Pervasives.Native.tuple14@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0))
:qid kinding_FStar.Pervasives.Native.tuple14@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@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))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.tuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(HasType (FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)
Tm_type))
 

:pattern ((FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
:qid kinding_FStar.Pervasives.Native.tuple14@tok.13))
)
:named kinding_FStar.Pervasives.Native.tuple14@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple14 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
(= (FStar.Pervasives.Native.tuple14 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.Native.tuple14 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))
:qid FStar.Pervasives.Native_pretyping_354c044bcd1b9686e6e741a2e2851b3b))

:named FStar.Pervasives.Native_pretyping_354c044bcd1b9686e6e741a2e2851b3b))

; </end encoding FStar.Pervasives.Native.tuple14>


; <Start encoding FStar.Pervasives.Native.Mktuple14>


; <start constructor FStar.Pervasives.Native.Mktuple14>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= 472
(Term_constr_id (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27)))
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid constructor_distinct_FStar.Pervasives.Native.Mktuple14))

:named constructor_distinct_FStar.Pervasives.Native.Mktuple14))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__a (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x0)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__a))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__b (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x1)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__b))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__c (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x2)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__c))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__d (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x3)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__d))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__e (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x4)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__e))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__e))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__f (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x5)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__f))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__f))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__g (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x6)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__g))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__g))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__h (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x7)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__h))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__h))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__i (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x8)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__i))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__i))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__j (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x9)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__j))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__j))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__k (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x10)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__k))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__k))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__l (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x11)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__l))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__l))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__m (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x12)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__m))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__m))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__n (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x13)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__n))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__n))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__1 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x14)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__1))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__2 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x15)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__2))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__3 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x16)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__3))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__4 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x17)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__4))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__5 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x18)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__5))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__5))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__6 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x19)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__6))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__6))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__7 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x20)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__7))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__7))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__8 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x21)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__8))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__8))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__9 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x22)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__9))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__9))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__10 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x23)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__10))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__10))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__11 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x24)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__11))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__11))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__12 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x25)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__12))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__12))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__13 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x26)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__13))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__13))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (FStar.Pervasives.Native.Mktuple14__14 (FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
@x27)
 

:pattern ((FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
:qid projection_inverse_FStar.Pervasives.Native.Mktuple14__14))

:named projection_inverse_FStar.Pervasives.Native.Mktuple14__14))
;;;;;;;;;;;;;;;;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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (= 475
(Term_constr_id FStar.Pervasives.Native.Mktuple14@tok))
:named fresh_token_FStar.Pervasives.Native.Mktuple14@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Native.Mktuple14@tok
Tm_arrow_484e3bf88a886900f7e695d7333615e9))
 

:pattern ((ApplyTT FStar.Pervasives.Native.Mktuple14@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.Mktuple14@tok))
:qid typing_tok_FStar.Pervasives.Native.Mktuple14@tok))

:named typing_tok_FStar.Pervasives.Native.Mktuple14@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
@x27)
(FStar.Pervasives.Native.Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.Mktuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
@x18)
@x19)
@x20)
@x21)
@x22)
@x23)
@x24)
@x25)
@x26)
@x27))
:qid equality_tok_FStar.Pervasives.Native.Mktuple14@tok))

:named equality_tok_FStar.Pervasives.Native.Mktuple14@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x13
Tm_type)
(HasTypeFuel @u0
@x14
Tm_type)
(HasTypeFuel @u0
@x15
@x1)
(HasTypeFuel @u0
@x16
@x2)
(HasTypeFuel @u0
@x17
@x3)
(HasTypeFuel @u0
@x18
@x4)
(HasTypeFuel @u0
@x19
@x5)
(HasTypeFuel @u0
@x20
@x6)
(HasTypeFuel @u0
@x21
@x7)
(HasTypeFuel @u0
@x22
@x8)
(HasTypeFuel @u0
@x23
@x9)
(HasTypeFuel @u0
@x24
@x10)
(HasTypeFuel @u0
@x25
@x11)
(HasTypeFuel @u0
@x26
@x12)
(HasTypeFuel @u0
@x27
@x13)
(HasTypeFuel @u0
@x28
@x14))
(HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
:qid data_typing_intro_FStar.Pervasives.Native.Mktuple14@tok))

:named data_typing_intro_FStar.Pervasives.Native.Mktuple14@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term) (@x34 Term) (@x35 Term) (@x36 Term) (@x37 Term) (@x38 Term) (@x39 Term) (@x40 Term) (@x41 Term) (@x42 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)
(FStar.Pervasives.Native.tuple14 @x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39
@x40
@x41
@x42))
(and (HasTypeFuel @u0
@x42
Tm_type)
(HasTypeFuel @u0
@x28
@x42)
(HasTypeFuel @u0
@x41
Tm_type)
(HasTypeFuel @u0
@x27
@x41)
(HasTypeFuel @u0
@x40
Tm_type)
(HasTypeFuel @u0
@x26
@x40)
(HasTypeFuel @u0
@x39
Tm_type)
(HasTypeFuel @u0
@x25
@x39)
(HasTypeFuel @u0
@x38
Tm_type)
(HasTypeFuel @u0
@x24
@x38)
(HasTypeFuel @u0
@x37
Tm_type)
(HasTypeFuel @u0
@x23
@x37)
(HasTypeFuel @u0
@x36
Tm_type)
(HasTypeFuel @u0
@x22
@x36)
(HasTypeFuel @u0
@x35
Tm_type)
(HasTypeFuel @u0
@x21
@x35)
(HasTypeFuel @u0
@x34
Tm_type)
(HasTypeFuel @u0
@x20
@x34)
(HasTypeFuel @u0
@x33
Tm_type)
(HasTypeFuel @u0
@x19
@x33)
(HasTypeFuel @u0
@x32
Tm_type)
(HasTypeFuel @u0
@x18
@x32)
(HasTypeFuel @u0
@x31
Tm_type)
(HasTypeFuel @u0
@x17
@x31)
(HasTypeFuel @u0
@x30
Tm_type)
(HasTypeFuel @u0
@x16
@x30)
(HasTypeFuel @u0
@x29
Tm_type)
(HasTypeFuel @u0
@x15
@x29)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x6
Tm_type)
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x8
Tm_type)
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x10
Tm_type)
(HasTypeFuel @u0
@x11
Tm_type)
(HasTypeFuel @u0
@x12
Tm_type)
(HasTypeFuel @u0
@x13
Tm_type)
(HasTypeFuel @u0
@x14
Tm_type)
(HasTypeFuel @u0
@x15
@x1)
(HasTypeFuel @u0
@x16
@x2)
(HasTypeFuel @u0
@x17
@x3)
(HasTypeFuel @u0
@x18
@x4)
(HasTypeFuel @u0
@x19
@x5)
(HasTypeFuel @u0
@x20
@x6)
(HasTypeFuel @u0
@x21
@x7)
(HasTypeFuel @u0
@x22
@x8)
(HasTypeFuel @u0
@x23
@x9)
(HasTypeFuel @u0
@x24
@x10)
(HasTypeFuel @u0
@x25
@x11)
(HasTypeFuel @u0
@x26
@x12)
(HasTypeFuel @u0
@x27
@x13)
(HasTypeFuel @u0
@x28
@x14)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)
(FStar.Pervasives.Native.tuple14 @x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39
@x40
@x41
@x42)))
:qid data_elim_FStar.Pervasives.Native.Mktuple14))

:named data_elim_FStar.Pervasives.Native.Mktuple14))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term) (@x18 Term) (@x19 Term) (@x20 Term) (@x21 Term) (@x22 Term) (@x23 Term) (@x24 Term) (@x25 Term) (@x26 Term) (@x27 Term) (@x28 Term) (@x29 Term) (@x30 Term) (@x31 Term) (@x32 Term) (@x33 Term) (@x34 Term) (@x35 Term) (@x36 Term) (@x37 Term) (@x38 Term) (@x39 Term) (@x40 Term) (@x41 Term) (@x42 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)
(FStar.Pervasives.Native.tuple14 @x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39
@x40
@x41
@x42))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x15
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x16
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x17
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x18
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x19
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x20
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x21
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x22
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x23
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x24
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x25
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x26
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x27
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x28
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Native.Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16
@x17
@x18
@x19
@x20
@x21
@x22
@x23
@x24
@x25
@x26
@x27
@x28)
(FStar.Pervasives.Native.tuple14 @x29
@x30
@x31
@x32
@x33
@x34
@x35
@x36
@x37
@x38
@x39
@x40
@x41
@x42)))
:qid subterm_ordering_FStar.Pervasives.Native.Mktuple14))

:named subterm_ordering_FStar.Pervasives.Native.Mktuple14))

; </end encoding FStar.Pervasives.Native.Mktuple14>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14; Namespace FStar.Pervasives.Native; Name FStar.Pervasives.Native.Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,5-158,12)
(forall ((@u0 Fuel) (@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) (@x14 Term) (@x15 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple14 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
(and (is-FStar.Pervasives.Native.Mktuple14 @x1)
(= @x2
(FStar.Pervasives.Native.Mktuple14__a @x1))
(= @x3
(FStar.Pervasives.Native.Mktuple14__b @x1))
(= @x4
(FStar.Pervasives.Native.Mktuple14__c @x1))
(= @x5
(FStar.Pervasives.Native.Mktuple14__d @x1))
(= @x6
(FStar.Pervasives.Native.Mktuple14__e @x1))
(= @x7
(FStar.Pervasives.Native.Mktuple14__f @x1))
(= @x8
(FStar.Pervasives.Native.Mktuple14__g @x1))
(= @x9
(FStar.Pervasives.Native.Mktuple14__h @x1))
(= @x10
(FStar.Pervasives.Native.Mktuple14__i @x1))
(= @x11
(FStar.Pervasives.Native.Mktuple14__j @x1))
(= @x12
(FStar.Pervasives.Native.Mktuple14__k @x1))
(= @x13
(FStar.Pervasives.Native.Mktuple14__l @x1))
(= @x14
(FStar.Pervasives.Native.Mktuple14__m @x1))
(= @x15
(FStar.Pervasives.Native.Mktuple14__n @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.Native.tuple14 @x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))
:qid fuel_guarded_inversion_FStar.Pervasives.Native.tuple14))

:named fuel_guarded_inversion_FStar.Pervasives.Native.tuple14))

; </end encoding >


; <Start encoding FStar.Pervasives.Native.tuple14__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: tuple14__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.Native.tuple14__uu___haseq; Namespace FStar.Pervasives.Native
(assert (! (forall ((@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))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1))
(Valid (Prims.hasEq @x2))
(Valid (Prims.hasEq @x3))
(Valid (Prims.hasEq @x4))
(Valid (Prims.hasEq @x5))
(Valid (Prims.hasEq @x6))
(Valid (Prims.hasEq @x7))
(Valid (Prims.hasEq @x8))
(Valid (Prims.hasEq @x9))
(Valid (Prims.hasEq @x10))
(Valid (Prims.hasEq @x11))
(Valid (Prims.hasEq @x12))
(Valid (Prims.hasEq @x13)))
(Valid (Prims.hasEq (FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
:qid assumption_FStar.Pervasives.Native.tuple14__uu___haseq))
:named assumption_FStar.Pervasives.Native.tuple14__uu___haseq))

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


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> Prims.bool
(declare-fun Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a
Tm_type)
:named kinding_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
:named FStar.Pervasives.Native_pre_typing_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a)
(and (forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.5))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.6))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.7))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.8))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.9))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.10))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.11))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.12))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.13))
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.14))
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a.15))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
:named FStar.Pervasives.Native_interpretation_Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))
(declare-fun FStar.Pervasives.Native.uu___is_Mktuple14@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.uu___is_Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple14))

:named token_correspondence_FStar.Pervasives.Native.uu___is_Mktuple14))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.uu___is_Mktuple14@tok
Tm_arrow_2de133cfaca100fc23d8bf4b3421db9a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.uu___is_Mktuple14@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.uu___is_Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple14.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.uu___is_Mktuple14@tok))
:qid function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple14))

:named function_token_typing_FStar.Pervasives.Native.uu___is_Mktuple14))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.uu___is_Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
Prims.bool))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.uu___is_Mktuple14))

:named typing_FStar.Pervasives.Native.uu___is_Mktuple14))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.Native.uu___is_Mktuple14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(159,4-159,13)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.uu___is_Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(BoxBool (is-FStar.Pervasives.Native.Mktuple14 @x14)))
 

:pattern ((FStar.Pervasives.Native.uu___is_Mktuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid disc_equation_FStar.Pervasives.Native.Mktuple14))

:named disc_equation_FStar.Pervasives.Native.Mktuple14))

; </end encoding FStar.Pervasives.Native.uu___is_Mktuple14>


; <Skipped FStar.Pervasives.Native.uu___is_Mktuple14/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'a
(declare-fun Tm_arrow_2e3216cab266e138debd68d0a503c177 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2e3216cab266e138debd68d0a503c177
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_2e3216cab266e138debd68d0a503c177
Tm_type)
:named kinding_Tm_arrow_2e3216cab266e138debd68d0a503c177))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2e3216cab266e138debd68d0a503c177)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2e3216cab266e138debd68d0a503c177))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_2e3216cab266e138debd68d0a503c177))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_2e3216cab266e138debd68d0a503c177))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2e3216cab266e138debd68d0a503c177)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,13-158,15)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2e3216cab266e138debd68d0a503c177))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_2e3216cab266e138debd68d0a503c177))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___1))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok
Tm_arrow_2e3216cab266e138debd68d0a503c177))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___1@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___1))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x0))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___1))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___1; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(160,6-160,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__1 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___1 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__1))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__1))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___1>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___1/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'b
(declare-fun Tm_arrow_958b0270e487d0bf5fe9191b9efaa127 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_958b0270e487d0bf5fe9191b9efaa127
Tm_type)
:named kinding_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_958b0270e487d0bf5fe9191b9efaa127)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_958b0270e487d0bf5fe9191b9efaa127)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,16-158,18)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___2))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok
Tm_arrow_958b0270e487d0bf5fe9191b9efaa127))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___2@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___2))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x1))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___2))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___2; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(161,6-161,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__2 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___2 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__2))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__2))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___2>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___2/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'c
(declare-fun Tm_arrow_08349f596f8c0acf60d1587bebe8c91b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_08349f596f8c0acf60d1587bebe8c91b
Tm_type)
:named kinding_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_08349f596f8c0acf60d1587bebe8c91b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_08349f596f8c0acf60d1587bebe8c91b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,19-158,21)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___3))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok
Tm_arrow_08349f596f8c0acf60d1587bebe8c91b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___3@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___3))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x2))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___3))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___3; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(162,6-162,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__3 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___3 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__3))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__3))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___3>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___3/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'd
(declare-fun Tm_arrow_2b069168147ba0f67f117ad5b0ac078b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_2b069168147ba0f67f117ad5b0ac078b
Tm_type)
:named kinding_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2b069168147ba0f67f117ad5b0ac078b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2b069168147ba0f67f117ad5b0ac078b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,22-158,24)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___4))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok
Tm_arrow_2b069168147ba0f67f117ad5b0ac078b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___4@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___4))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x3))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___4))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___4; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(163,6-163,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__4 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__4))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__4))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___4>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___4/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'e
(declare-fun Tm_arrow_1e38bb16245a24a197c44a262fee7bf1 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_1e38bb16245a24a197c44a262fee7bf1
Tm_type)
:named kinding_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1e38bb16245a24a197c44a262fee7bf1)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1e38bb16245a24a197c44a262fee7bf1)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,25-158,27)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___5))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___5))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok
Tm_arrow_1e38bb16245a24a197c44a262fee7bf1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___5.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___5@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___5))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___5))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x4))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___5))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___5))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___5; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(164,6-164,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__5 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___5 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__5))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__5))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___5>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___5/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'f
(declare-fun Tm_arrow_7a148953a3884454d8a1dffddce086bb () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7a148953a3884454d8a1dffddce086bb
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7a148953a3884454d8a1dffddce086bb
Tm_type)
:named kinding_Tm_arrow_7a148953a3884454d8a1dffddce086bb))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7a148953a3884454d8a1dffddce086bb)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7a148953a3884454d8a1dffddce086bb))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7a148953a3884454d8a1dffddce086bb))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7a148953a3884454d8a1dffddce086bb))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7a148953a3884454d8a1dffddce086bb)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,28-158,30)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7a148953a3884454d8a1dffddce086bb))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7a148953a3884454d8a1dffddce086bb))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___6))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___6))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok
Tm_arrow_7a148953a3884454d8a1dffddce086bb))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___6.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___6@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___6))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___6))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x5))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___6))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___6))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___6; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(165,6-165,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__6 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___6 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__6))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__6))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___6>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___6/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'g
(declare-fun Tm_arrow_812eeb3fdab56dfea8e419236740acb0 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_812eeb3fdab56dfea8e419236740acb0
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_812eeb3fdab56dfea8e419236740acb0
Tm_type)
:named kinding_Tm_arrow_812eeb3fdab56dfea8e419236740acb0))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_812eeb3fdab56dfea8e419236740acb0)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_812eeb3fdab56dfea8e419236740acb0))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_812eeb3fdab56dfea8e419236740acb0))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_812eeb3fdab56dfea8e419236740acb0))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_812eeb3fdab56dfea8e419236740acb0)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,31-158,33)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_812eeb3fdab56dfea8e419236740acb0))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_812eeb3fdab56dfea8e419236740acb0))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___7))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___7))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok
Tm_arrow_812eeb3fdab56dfea8e419236740acb0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___7.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___7@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___7))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___7))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x6))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___7))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___7))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___7; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(166,6-166,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__7 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___7 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__7))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__7))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___7>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___7/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'h
(declare-fun Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b
Tm_type)
:named kinding_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x8))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,34-158,36)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___8))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___8))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok
Tm_arrow_9dc932ce7cdfd6fa57f6536787fcb65b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___8.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___8@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___8))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___8))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x7))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___8))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___8))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___8; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(167,6-167,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__8 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___8 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__8))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__8))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___8>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___8/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'i
(declare-fun Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a
Tm_type)
:named kinding_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x9))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,37-158,39)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___9))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___9))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok
Tm_arrow_2600722933f06bc55e28bb3fc2ce4a6a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___9.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___9@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___9))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___9))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x8))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___9))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___9))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___9; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(168,6-168,8)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__9 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___9 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__9))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__9))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___9>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___9/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'j
(declare-fun Tm_arrow_f51203e57fd66f9e9293b8962c57edfe () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_f51203e57fd66f9e9293b8962c57edfe
Tm_type)
:named kinding_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f51203e57fd66f9e9293b8962c57edfe)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f51203e57fd66f9e9293b8962c57edfe)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x10))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,40-158,42)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___10))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___10))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok
Tm_arrow_f51203e57fd66f9e9293b8962c57edfe))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___10.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___10@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___10))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___10))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x9))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___10))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___10))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___10; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(169,6-169,9)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__10 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___10 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__10))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__10))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___10>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___10/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'k
(declare-fun Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7
Tm_type)
:named kinding_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x11))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,43-158,45)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___11))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___11))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok
Tm_arrow_7c34e0c28edc5fc4ad24d0b749c0adb7))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___11.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___11@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___11))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___11))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x10))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___11))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___11))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___11; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(170,6-170,9)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__11 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___11 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__11))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__11))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___11>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___11/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'l
(declare-fun Tm_arrow_8772cc50ea320af17b3f2371c273679a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8772cc50ea320af17b3f2371c273679a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_8772cc50ea320af17b3f2371c273679a
Tm_type)
:named kinding_Tm_arrow_8772cc50ea320af17b3f2371c273679a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8772cc50ea320af17b3f2371c273679a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8772cc50ea320af17b3f2371c273679a))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_8772cc50ea320af17b3f2371c273679a))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_8772cc50ea320af17b3f2371c273679a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8772cc50ea320af17b3f2371c273679a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x12))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,46-158,48)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8772cc50ea320af17b3f2371c273679a))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_8772cc50ea320af17b3f2371c273679a))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___12))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___12))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok
Tm_arrow_8772cc50ea320af17b3f2371c273679a))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___12.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___12@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___12))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___12))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x11))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___12))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___12))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___12; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(171,6-171,9)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__12 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___12 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__12))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__12))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___12>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___12/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'm
(declare-fun Tm_arrow_039da0b9a8da1a651a1c570e55456614 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_039da0b9a8da1a651a1c570e55456614
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_039da0b9a8da1a651a1c570e55456614
Tm_type)
:named kinding_Tm_arrow_039da0b9a8da1a651a1c570e55456614))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_039da0b9a8da1a651a1c570e55456614)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_039da0b9a8da1a651a1c570e55456614))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_039da0b9a8da1a651a1c570e55456614))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_039da0b9a8da1a651a1c570e55456614))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_039da0b9a8da1a651a1c570e55456614)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x13))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,49-158,51)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_039da0b9a8da1a651a1c570e55456614))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_039da0b9a8da1a651a1c570e55456614))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___13))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___13))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok
Tm_arrow_039da0b9a8da1a651a1c570e55456614))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___13.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___13@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___13))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___13))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x12))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___13))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___13))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___13; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(172,6-172,9)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__13 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___13 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__13))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__13))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___13>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___13/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;projectee:       ((((((((((((('a * 'b) * 'c) * 'd) * 'e) * 'f) * 'g) * 'h) * 'i) * 'j) * 'k) * 'l) * 'm) * 'n)   -> 'n
(declare-fun Tm_arrow_579ada2eb036c15c7306dac5b648153e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_579ada2eb036c15c7306dac5b648153e
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! (HasType Tm_arrow_579ada2eb036c15c7306dac5b648153e
Tm_type)
:named kinding_Tm_arrow_579ada2eb036c15c7306dac5b648153e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_579ada2eb036c15c7306dac5b648153e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_579ada2eb036c15c7306dac5b648153e))
:qid FStar.Pervasives.Native_pre_typing_Tm_arrow_579ada2eb036c15c7306dac5b648153e))

:named FStar.Pervasives.Native_pre_typing_Tm_arrow_579ada2eb036c15c7306dac5b648153e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_579ada2eb036c15c7306dac5b648153e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type)
(HasType @x15
(FStar.Pervasives.Native.tuple14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.8))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.9))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.11))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.12))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@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))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.14))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(158,52-158,54)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e.15))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_579ada2eb036c15c7306dac5b648153e))
:qid FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e))

:named FStar.Pervasives.Native_interpretation_Tm_arrow_579ada2eb036c15c7306dac5b648153e))
(declare-fun FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9)
(forall ((@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) (@x14 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
(FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14))
:qid token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___14))

:named token_correspondence_FStar.Pervasives.Native.__proj__Mktuple14__item___14))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok
Tm_arrow_579ada2eb036c15c7306dac5b648153e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9)
(forall ((@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) (@x14 Term) (@x15 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___14.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.Native.__proj__Mktuple14__item___14@tok))
:qid function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___14))

:named function_token_typing_FStar.Pervasives.Native.__proj__Mktuple14__item___14))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9)
(forall ((@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) (@x14 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
Tm_type)
(HasType @x5
Tm_type)
(HasType @x6
Tm_type)
(HasType @x7
Tm_type)
(HasType @x8
Tm_type)
(HasType @x9
Tm_type)
(HasType @x10
Tm_type)
(HasType @x11
Tm_type)
(HasType @x12
Tm_type)
(HasType @x13
Tm_type)
(HasType @x14
(FStar.Pervasives.Native.tuple14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))
(HasType (FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
@x13))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid typing_FStar.Pervasives.Native.__proj__Mktuple14__item___14))

:named typing_FStar.Pervasives.Native.__proj__Mktuple14__item___14))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.Native.__proj__Mktuple14__item___14; Namespace FStar.Pervasives.Native
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.Native.fst(173,6-173,9)
(forall ((@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) (@x14 Term))
 (! (= (FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(FStar.Pervasives.Native.Mktuple14__14 @x14))
 

:pattern ((FStar.Pervasives.Native.__proj__Mktuple14__item___14 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8
@x9
@x10
@x11
@x12
@x13
@x14))
:qid proj_equation_FStar.Pervasives.Native.Mktuple14__14))

:named proj_equation_FStar.Pervasives.Native.Mktuple14__14))

; </end encoding FStar.Pervasives.Native.__proj__Mktuple14__item___14>


; <Skipped FStar.Pervasives.Native.__proj__Mktuple14__item___14/>


; End Externals for module FStar.Pervasives.Native

;;; End module FStar.Pervasives.Native (2645 decls; total size 2560395)

;;; Start interface FStar.Pervasives

; Externals for interface FStar.Pervasives


; <Start encoding FStar.Pervasives.remove_unused_type_parameters>

(declare-fun FStar.Pervasives.remove_unused_type_parameters (Term) Term)
;;;;;;;;;;;;;;;;_: Prims.list Prims.int -> Prims.unit
(declare-fun Tm_arrow_555d62757eeaf90340982fcdf25f6704 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_555d62757eeaf90340982fcdf25f6704
;;; Fact-ids: Name FStar.Pervasives.remove_unused_type_parameters; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_555d62757eeaf90340982fcdf25f6704
Tm_type)
:named kinding_Tm_arrow_555d62757eeaf90340982fcdf25f6704))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.remove_unused_type_parameters; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,52-55,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,52-55,56)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_555d62757eeaf90340982fcdf25f6704)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_555d62757eeaf90340982fcdf25f6704))
:qid FStar.Pervasives_pre_typing_Tm_arrow_555d62757eeaf90340982fcdf25f6704))

:named FStar.Pervasives_pre_typing_Tm_arrow_555d62757eeaf90340982fcdf25f6704))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_555d62757eeaf90340982fcdf25f6704
;;; Fact-ids: Name FStar.Pervasives.remove_unused_type_parameters; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,52-55,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,52-55,56)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_555d62757eeaf90340982fcdf25f6704)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,52-55,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,52-55,56)
(forall ((@x1 Term))
 (! (implies (HasType @x1
(Prims.list Prims.int))
(HasType (ApplyTT @x0
@x1)
Prims.unit))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_555d62757eeaf90340982fcdf25f6704.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_555d62757eeaf90340982fcdf25f6704))
:qid FStar.Pervasives_interpretation_Tm_arrow_555d62757eeaf90340982fcdf25f6704))

:named FStar.Pervasives_interpretation_Tm_arrow_555d62757eeaf90340982fcdf25f6704))
(declare-fun FStar.Pervasives.remove_unused_type_parameters@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.remove_unused_type_parameters; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.remove_unused_type_parameters@tok
@x0)
(FStar.Pervasives.remove_unused_type_parameters @x0))
 

:pattern ((ApplyTT FStar.Pervasives.remove_unused_type_parameters@tok
@x0))
:qid token_correspondence_FStar.Pervasives.remove_unused_type_parameters))

:named token_correspondence_FStar.Pervasives.remove_unused_type_parameters))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.remove_unused_type_parameters; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.remove_unused_type_parameters@tok
Tm_arrow_555d62757eeaf90340982fcdf25f6704))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.remove_unused_type_parameters@tok
@x1)
(FStar.Pervasives.remove_unused_type_parameters @x1))
 

:pattern ((FStar.Pervasives.remove_unused_type_parameters @x1))
:qid function_token_typing_FStar.Pervasives.remove_unused_type_parameters.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.remove_unused_type_parameters@tok))
:qid function_token_typing_FStar.Pervasives.remove_unused_type_parameters))

:named function_token_typing_FStar.Pervasives.remove_unused_type_parameters))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.remove_unused_type_parameters; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(55,4-55,33)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.int))
(HasType (FStar.Pervasives.remove_unused_type_parameters @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.remove_unused_type_parameters @x0))
:qid typing_FStar.Pervasives.remove_unused_type_parameters))

:named typing_FStar.Pervasives.remove_unused_type_parameters))

; </end encoding FStar.Pervasives.remove_unused_type_parameters>


; <Start encoding FStar.Pervasives.pattern>

(declare-fun FStar.Pervasives.pattern () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pattern; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.pattern
Tm_type)
:named function_token_typing_FStar.Pervasives.pattern))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pattern; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.pattern
Tm_type)
:named typing_FStar.Pervasives.pattern))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pattern
;;; Fact-ids: Name FStar.Pervasives.pattern; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.pattern
Prims.unit)
:named equation_FStar.Pervasives.pattern))

; </end encoding FStar.Pervasives.pattern>


; <Start encoding FStar.Pervasives.smt_pat>

(declare-fun FStar.Pervasives.smt_pat (Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> FStar.Pervasives.pattern
(declare-fun Tm_arrow_ce7b692455ad1649f97902066cf7c9aa () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa
;;; Fact-ids: Name FStar.Pervasives.smt_pat; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_ce7b692455ad1649f97902066cf7c9aa
Tm_type)
:named kinding_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.smt_pat; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ce7b692455ad1649f97902066cf7c9aa)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))

:named FStar.Pervasives_pre_typing_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa
;;; Fact-ids: Name FStar.Pervasives.smt_pat; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ce7b692455ad1649f97902066cf7c9aa)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
FStar.Pervasives.pattern))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,36-62,43)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))
:qid FStar.Pervasives_interpretation_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))

:named FStar.Pervasives_interpretation_Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))
(declare-fun FStar.Pervasives.smt_pat@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.smt_pat; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.smt_pat@tok
@x0)
@x1)
(FStar.Pervasives.smt_pat @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.smt_pat@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.smt_pat))

:named token_correspondence_FStar.Pervasives.smt_pat))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.smt_pat; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.smt_pat@tok
Tm_arrow_ce7b692455ad1649f97902066cf7c9aa))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.smt_pat@tok
@x1)
@x2)
(FStar.Pervasives.smt_pat @x1
@x2))
 

:pattern ((FStar.Pervasives.smt_pat @x1
@x2))
:qid function_token_typing_FStar.Pervasives.smt_pat.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.smt_pat@tok))
:qid function_token_typing_FStar.Pervasives.smt_pat))

:named function_token_typing_FStar.Pervasives.smt_pat))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.smt_pat; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(62,4-62,11)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.smt_pat @x0
@x1)
FStar.Pervasives.pattern))
 

:pattern ((FStar.Pervasives.smt_pat @x0
@x1))
:qid typing_FStar.Pervasives.smt_pat))

:named typing_FStar.Pervasives.smt_pat))

; </end encoding FStar.Pervasives.smt_pat>


; <Start encoding FStar.Pervasives.smt_pat_or>

(declare-fun FStar.Pervasives.smt_pat_or (Term) Term)
;;;;;;;;;;;;;;;;x: Prims.list (Prims.list FStar.Pervasives.pattern) -> FStar.Pervasives.pattern
(declare-fun Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41
;;; Fact-ids: Name FStar.Pervasives.smt_pat_or; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41
Tm_type)
:named kinding_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.smt_pat_or; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,46-74,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,46-74,53)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))
:qid FStar.Pervasives_pre_typing_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))

:named FStar.Pervasives_pre_typing_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41
;;; Fact-ids: Name FStar.Pervasives.smt_pat_or; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,46-74,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,46-74,53)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,46-74,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,46-74,53)
(forall ((@x1 Term))
 (! (implies (HasType @x1
(Prims.list (Prims.list FStar.Pervasives.pattern)))
(HasType (ApplyTT @x0
@x1)
FStar.Pervasives.pattern))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))
:qid FStar.Pervasives_interpretation_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))

:named FStar.Pervasives_interpretation_Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))
(declare-fun FStar.Pervasives.smt_pat_or@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.smt_pat_or; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.smt_pat_or@tok
@x0)
(FStar.Pervasives.smt_pat_or @x0))
 

:pattern ((ApplyTT FStar.Pervasives.smt_pat_or@tok
@x0))
:qid token_correspondence_FStar.Pervasives.smt_pat_or))

:named token_correspondence_FStar.Pervasives.smt_pat_or))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.smt_pat_or; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.smt_pat_or@tok
Tm_arrow_cbfaca2770c8ef7d6393b664b7ea1a41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.smt_pat_or@tok
@x1)
(FStar.Pervasives.smt_pat_or @x1))
 

:pattern ((FStar.Pervasives.smt_pat_or @x1))
:qid function_token_typing_FStar.Pervasives.smt_pat_or.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.smt_pat_or@tok))
:qid function_token_typing_FStar.Pervasives.smt_pat_or))

:named function_token_typing_FStar.Pervasives.smt_pat_or))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.smt_pat_or; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(74,4-74,14)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list (Prims.list FStar.Pervasives.pattern)))
(HasType (FStar.Pervasives.smt_pat_or @x0)
FStar.Pervasives.pattern))
 

:pattern ((FStar.Pervasives.smt_pat_or @x0))
:qid typing_FStar.Pervasives.smt_pat_or))

:named typing_FStar.Pervasives.smt_pat_or))

; </end encoding FStar.Pervasives.smt_pat_or>


; <Start encoding FStar.Pervasives.eqtype_u>

(declare-fun FStar.Pervasives.eqtype_u () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.eqtype_u; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.eqtype_u
Tm_type)
:named function_token_typing_FStar.Pervasives.eqtype_u))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.eqtype_u; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.eqtype_u
Tm_type)
:named typing_FStar.Pervasives.eqtype_u))

;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.eqtype_u
;;; Fact-ids: Name FStar.Pervasives.eqtype_u; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.eqtype_u
Tm_refine_414d0a9f578ab0048252f8c8f552b99f)
:named equation_FStar.Pervasives.eqtype_u))

; </end encoding FStar.Pervasives.eqtype_u>


; <Skipped FStar.Pervasives.Lemma/>


; <Start encoding FStar.Pervasives.spinoff>

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

(declare-fun FStar.Pervasives.spinoff@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.spinoff@tok
@x0)
(FStar.Pervasives.spinoff @x0))
 

:pattern ((ApplyTT FStar.Pervasives.spinoff@tok
@x0))
:qid token_correspondence_FStar.Pervasives.spinoff))

:named token_correspondence_FStar.Pervasives.spinoff))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.spinoff@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.spinoff@tok
@x1)
(FStar.Pervasives.spinoff @x1))
 

:pattern ((FStar.Pervasives.spinoff @x1))
:qid function_token_typing_FStar.Pervasives.spinoff.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.spinoff@tok))
:qid function_token_typing_FStar.Pervasives.spinoff))

:named function_token_typing_FStar.Pervasives.spinoff))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(119,4-119,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.spinoff @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.spinoff @x0))
:qid typing_FStar.Pervasives.spinoff))

:named typing_FStar.Pervasives.spinoff))

; </end encoding FStar.Pervasives.spinoff>


; <Start encoding FStar.Pervasives.assert_spinoff>

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

;;;;;;;;;;;;;;;;p: Type -> Prims.Pure Prims.unit
(declare-fun Tm_arrow_071538fd1c72fb82c7bb7b280daddf84 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84
;;; Fact-ids: Name FStar.Pervasives.assert_spinoff; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_071538fd1c72fb82c7bb7b280daddf84
Tm_type)
:named kinding_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.assert_spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,36-122,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,36-122,40)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_071538fd1c72fb82c7bb7b280daddf84)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))
:qid FStar.Pervasives_pre_typing_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))

:named FStar.Pervasives_pre_typing_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84
;;; Fact-ids: Name FStar.Pervasives.assert_spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,36-122,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,36-122,40)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_071538fd1c72fb82c7bb7b280daddf84)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,36-122,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,36-122,40)
(forall ((@x1 Term))
 (! (implies (and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71)
(FStar.Pervasives.spinoff (Prims.squash @x1))
)

(HasType @x1
Tm_type))
(HasType (ApplyTT @x0
@x1)
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))
:qid FStar.Pervasives_interpretation_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))

:named FStar.Pervasives_interpretation_Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))
(declare-fun FStar.Pervasives.assert_spinoff@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.assert_spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.assert_spinoff@tok
@x0)
(FStar.Pervasives.assert_spinoff @x0))
 

:pattern ((ApplyTT FStar.Pervasives.assert_spinoff@tok
@x0))
:qid token_correspondence_FStar.Pervasives.assert_spinoff))

:named token_correspondence_FStar.Pervasives.assert_spinoff))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.assert_spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.assert_spinoff@tok
Tm_arrow_071538fd1c72fb82c7bb7b280daddf84))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.assert_spinoff@tok
@x1)
(FStar.Pervasives.assert_spinoff @x1))
 

:pattern ((FStar.Pervasives.assert_spinoff @x1))
:qid function_token_typing_FStar.Pervasives.assert_spinoff.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.assert_spinoff@tok))
:qid function_token_typing_FStar.Pervasives.assert_spinoff))

:named function_token_typing_FStar.Pervasives.assert_spinoff))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.assert_spinoff; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,4-122,18)
(forall ((@x0 Term))
 (! (implies (and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(122,51-122,71)
(FStar.Pervasives.spinoff (Prims.squash @x0))
)

(HasType @x0
Tm_type))
(HasType (FStar.Pervasives.assert_spinoff @x0)
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0)))
 

:pattern ((FStar.Pervasives.assert_spinoff @x0))
:qid typing_FStar.Pervasives.assert_spinoff))

:named typing_FStar.Pervasives.assert_spinoff))

; </end encoding FStar.Pervasives.assert_spinoff>


; <Start encoding FStar.Pervasives.id>

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

(declare-fun FStar.Pervasives.id@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.id; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.id@tok
@x0)
@x1)
(FStar.Pervasives.id @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.id@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.id))

:named token_correspondence_FStar.Pervasives.id))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.id; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.id@tok
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.id@tok
@x1)
@x2)
(FStar.Pervasives.id @x1
@x2))
 

:pattern ((FStar.Pervasives.id @x1
@x2))
:qid function_token_typing_FStar.Pervasives.id.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.id@tok))
:qid function_token_typing_FStar.Pervasives.id))

:named function_token_typing_FStar.Pervasives.id))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.id; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.id @x0
@x1)
@x0))
 

:pattern ((FStar.Pervasives.id @x0
@x1))
:qid typing_FStar.Pervasives.id))

:named typing_FStar.Pervasives.id))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.id
;;; Fact-ids: Name FStar.Pervasives.id; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(126,4-126,6)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.id @x0
@x1)
@x1)
 

:pattern ((FStar.Pervasives.id @x0
@x1))
:qid equation_FStar.Pervasives.id))

:named equation_FStar.Pervasives.id))

; </end encoding FStar.Pervasives.id>


; <Start encoding FStar.Pervasives.trivial_pure_post>

(declare-fun FStar.Pervasives.trivial_pure_post (Term) Term)
;;;;;;;;;;;;;;;;a: Type -> Prims.pure_post a
(declare-fun Tm_arrow_53823f439377767fbcd3e27ebcdb971b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_53823f439377767fbcd3e27ebcdb971b
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_53823f439377767fbcd3e27ebcdb971b
Tm_type)
:named kinding_Tm_arrow_53823f439377767fbcd3e27ebcdb971b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,34-130,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,34-130,45)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_53823f439377767fbcd3e27ebcdb971b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_53823f439377767fbcd3e27ebcdb971b))
:qid FStar.Pervasives_pre_typing_Tm_arrow_53823f439377767fbcd3e27ebcdb971b))

:named FStar.Pervasives_pre_typing_Tm_arrow_53823f439377767fbcd3e27ebcdb971b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_53823f439377767fbcd3e27ebcdb971b
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,34-130,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,34-130,45)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_53823f439377767fbcd3e27ebcdb971b)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,34-130,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,34-130,45)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
(Prims.pure_post @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_53823f439377767fbcd3e27ebcdb971b.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_53823f439377767fbcd3e27ebcdb971b))
:qid FStar.Pervasives_interpretation_Tm_arrow_53823f439377767fbcd3e27ebcdb971b))

:named FStar.Pervasives_interpretation_Tm_arrow_53823f439377767fbcd3e27ebcdb971b))
(declare-fun FStar.Pervasives.trivial_pure_post@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.trivial_pure_post@tok
@x0)
(FStar.Pervasives.trivial_pure_post @x0))
 

:pattern ((ApplyTT FStar.Pervasives.trivial_pure_post@tok
@x0))
:qid token_correspondence_FStar.Pervasives.trivial_pure_post))

:named token_correspondence_FStar.Pervasives.trivial_pure_post))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.trivial_pure_post@tok
Tm_arrow_53823f439377767fbcd3e27ebcdb971b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.trivial_pure_post@tok
@x1)
(FStar.Pervasives.trivial_pure_post @x1))
 

:pattern ((FStar.Pervasives.trivial_pure_post @x1))
:qid function_token_typing_FStar.Pervasives.trivial_pure_post.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.trivial_pure_post@tok))
:qid function_token_typing_FStar.Pervasives.trivial_pure_post))

:named function_token_typing_FStar.Pervasives.trivial_pure_post))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.trivial_pure_post @x0)
(Prims.pure_post @x0)))
 

:pattern ((FStar.Pervasives.trivial_pure_post @x0))
:qid typing_FStar.Pervasives.trivial_pure_post))

:named typing_FStar.Pervasives.trivial_pure_post))

(declare-fun Tm_abs_5e34897418ce4950a4effcc8c159cf53 (Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_5e34897418ce4950a4effcc8c159cf53
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,57-130,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,57-130,61)
(forall ((@x0 Term))
 (! (HasType (Tm_abs_5e34897418ce4950a4effcc8c159cf53 @x0)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
 

:pattern ((Tm_abs_5e34897418ce4950a4effcc8c159cf53 @x0))
:qid typing_Tm_abs_5e34897418ce4950a4effcc8c159cf53))

:named typing_Tm_abs_5e34897418ce4950a4effcc8c159cf53))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_5e34897418ce4950a4effcc8c159cf53
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,57-130,61); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,57-130,61)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (Tm_abs_5e34897418ce4950a4effcc8c159cf53 @x1)
@x0)
Prims.l_True)
 

:pattern ((ApplyTT (Tm_abs_5e34897418ce4950a4effcc8c159cf53 @x1)
@x0))
:qid interpretation_Tm_abs_5e34897418ce4950a4effcc8c159cf53))

:named interpretation_Tm_abs_5e34897418ce4950a4effcc8c159cf53))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.trivial_pure_post
;;; Fact-ids: Name FStar.Pervasives.trivial_pure_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(130,4-130,21)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.trivial_pure_post @x0)
(Tm_abs_5e34897418ce4950a4effcc8c159cf53 @x0))
 

:pattern ((FStar.Pervasives.trivial_pure_post @x0))
:qid equation_FStar.Pervasives.trivial_pure_post))

:named equation_FStar.Pervasives.trivial_pure_post))

; </end encoding FStar.Pervasives.trivial_pure_post>


; <Start encoding FStar.Pervasives.ambient>

(declare-fun FStar.Pervasives.ambient (Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> Type
(declare-fun Tm_arrow_9e007179360e2932d75ab29019e3d7fa () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9e007179360e2932d75ab29019e3d7fa
;;; Fact-ids: Name FStar.Pervasives.ambient; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_9e007179360e2932d75ab29019e3d7fa
Tm_type)
:named kinding_Tm_arrow_9e007179360e2932d75ab29019e3d7fa))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9e007179360e2932d75ab29019e3d7fa)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9e007179360e2932d75ab29019e3d7fa))
:qid FStar.Pervasives_pre_typing_Tm_arrow_9e007179360e2932d75ab29019e3d7fa))

:named FStar.Pervasives_pre_typing_Tm_arrow_9e007179360e2932d75ab29019e3d7fa))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9e007179360e2932d75ab29019e3d7fa
;;; Fact-ids: Name FStar.Pervasives.ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9e007179360e2932d75ab29019e3d7fa)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_9e007179360e2932d75ab29019e3d7fa.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,32-140,37)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_9e007179360e2932d75ab29019e3d7fa.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9e007179360e2932d75ab29019e3d7fa))
:qid FStar.Pervasives_interpretation_Tm_arrow_9e007179360e2932d75ab29019e3d7fa))

:named FStar.Pervasives_interpretation_Tm_arrow_9e007179360e2932d75ab29019e3d7fa))
(declare-fun FStar.Pervasives.ambient@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ambient@tok
@x0)
@x1)
(FStar.Pervasives.ambient @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.ambient@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.ambient))

:named token_correspondence_FStar.Pervasives.ambient))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ambient@tok
Tm_arrow_9e007179360e2932d75ab29019e3d7fa))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ambient@tok
@x1)
@x2)
(FStar.Pervasives.ambient @x1
@x2))
 

:pattern ((FStar.Pervasives.ambient @x1
@x2))
:qid function_token_typing_FStar.Pervasives.ambient.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ambient@tok))
:qid function_token_typing_FStar.Pervasives.ambient))

:named function_token_typing_FStar.Pervasives.ambient))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(140,4-140,11)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.ambient @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.ambient @x0
@x1))
:qid typing_FStar.Pervasives.ambient))

:named typing_FStar.Pervasives.ambient))

; </end encoding FStar.Pervasives.ambient>


; <Start encoding FStar.Pervasives.intro_ambient>

(declare-fun FStar.Pervasives.intro_ambient (Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> Prims.squash (FStar.Pervasives.ambient x)
(declare-fun Tm_arrow_6fc6334d56387f3d408122a4bd045e7e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e
;;; Fact-ids: Name FStar.Pervasives.intro_ambient; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_6fc6334d56387f3d408122a4bd045e7e
Tm_type)
:named kinding_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.intro_ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6fc6334d56387f3d408122a4bd045e7e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))
:qid FStar.Pervasives_pre_typing_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))

:named FStar.Pervasives_pre_typing_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e
;;; Fact-ids: Name FStar.Pervasives.intro_ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6fc6334d56387f3d408122a4bd045e7e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(Prims.squash (FStar.Pervasives.ambient @x1
@x2))))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,42-143,62)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))
:qid FStar.Pervasives_interpretation_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))

:named FStar.Pervasives_interpretation_Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))
(declare-fun FStar.Pervasives.intro_ambient@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.intro_ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.intro_ambient@tok
@x0)
@x1)
(FStar.Pervasives.intro_ambient @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.intro_ambient@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.intro_ambient))

:named token_correspondence_FStar.Pervasives.intro_ambient))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.intro_ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.intro_ambient@tok
Tm_arrow_6fc6334d56387f3d408122a4bd045e7e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.intro_ambient@tok
@x1)
@x2)
(FStar.Pervasives.intro_ambient @x1
@x2))
 

:pattern ((FStar.Pervasives.intro_ambient @x1
@x2))
:qid function_token_typing_FStar.Pervasives.intro_ambient.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.intro_ambient@tok))
:qid function_token_typing_FStar.Pervasives.intro_ambient))

:named function_token_typing_FStar.Pervasives.intro_ambient))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.intro_ambient; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(143,4-143,17)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.intro_ambient @x0
@x1)
(Prims.squash (FStar.Pervasives.ambient @x0
@x1))))
 

:pattern ((FStar.Pervasives.intro_ambient @x0
@x1))
:qid typing_FStar.Pervasives.intro_ambient))

:named typing_FStar.Pervasives.intro_ambient))

; </end encoding FStar.Pervasives.intro_ambient>


; <Start encoding FStar.Pervasives.normalize_term>

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

(declare-fun FStar.Pervasives.normalize_term@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.normalize_term; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.normalize_term@tok
@x0)
@x1)
(FStar.Pervasives.normalize_term @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.normalize_term@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.normalize_term))

:named token_correspondence_FStar.Pervasives.normalize_term))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.normalize_term; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.normalize_term@tok
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.normalize_term@tok
@x1)
@x2)
(FStar.Pervasives.normalize_term @x1
@x2))
 

:pattern ((FStar.Pervasives.normalize_term @x1
@x2))
:qid function_token_typing_FStar.Pervasives.normalize_term.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.normalize_term@tok))
:qid function_token_typing_FStar.Pervasives.normalize_term))

:named function_token_typing_FStar.Pervasives.normalize_term))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.normalize_term; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(150,4-150,18)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.normalize_term @x0
@x1)
@x0))
 

:pattern ((FStar.Pervasives.normalize_term @x0
@x1))
:qid typing_FStar.Pervasives.normalize_term))

:named typing_FStar.Pervasives.normalize_term))

; </end encoding FStar.Pervasives.normalize_term>


; <Start encoding FStar.Pervasives.normalize>

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

(declare-fun FStar.Pervasives.normalize@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.normalize; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.normalize@tok
@x0)
(FStar.Pervasives.normalize @x0))
 

:pattern ((ApplyTT FStar.Pervasives.normalize@tok
@x0))
:qid token_correspondence_FStar.Pervasives.normalize))

:named token_correspondence_FStar.Pervasives.normalize))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.normalize; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.normalize@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.normalize@tok
@x1)
(FStar.Pervasives.normalize @x1))
 

:pattern ((FStar.Pervasives.normalize @x1))
:qid function_token_typing_FStar.Pervasives.normalize.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.normalize@tok))
:qid function_token_typing_FStar.Pervasives.normalize))

:named function_token_typing_FStar.Pervasives.normalize))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.normalize; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(154,4-154,13)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.normalize @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.normalize @x0))
:qid typing_FStar.Pervasives.normalize))

:named typing_FStar.Pervasives.normalize))

; </end encoding FStar.Pervasives.normalize>


; <Start encoding FStar.Pervasives.norm_step>

(declare-fun FStar.Pervasives.norm_step () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.norm_step; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.norm_step
Tm_type)
:named function_token_typing_FStar.Pervasives.norm_step))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.norm_step; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.norm_step
Tm_type)
:named typing_FStar.Pervasives.norm_step))

; </end encoding FStar.Pervasives.norm_step>


; <Start encoding FStar.Pervasives.simplify>

(declare-fun FStar.Pervasives.simplify (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.simplify; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(161,4-161,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(161,4-161,12)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.simplify @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.simplify @u0))
:qid typing_FStar.Pervasives.simplify))

:named typing_FStar.Pervasives.simplify))

; </end encoding FStar.Pervasives.simplify>


; <Start encoding FStar.Pervasives.weak>

(declare-fun FStar.Pervasives.weak (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.weak; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(164,4-164,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(164,4-164,8)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.weak @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.weak @u0))
:qid typing_FStar.Pervasives.weak))

:named typing_FStar.Pervasives.weak))

; </end encoding FStar.Pervasives.weak>


; <Start encoding FStar.Pervasives.hnf>

(declare-fun FStar.Pervasives.hnf (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.hnf; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(167,4-167,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(167,4-167,7)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.hnf @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.hnf @u0))
:qid typing_FStar.Pervasives.hnf))

:named typing_FStar.Pervasives.hnf))

; </end encoding FStar.Pervasives.hnf>


; <Start encoding FStar.Pervasives.primops>

(declare-fun FStar.Pervasives.primops (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.primops; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(170,4-170,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(170,4-170,11)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.primops @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.primops @u0))
:qid typing_FStar.Pervasives.primops))

:named typing_FStar.Pervasives.primops))

; </end encoding FStar.Pervasives.primops>


; <Start encoding FStar.Pervasives.delta>

(declare-fun FStar.Pervasives.delta (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.delta; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(173,4-173,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(173,4-173,9)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.delta @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.delta @u0))
:qid typing_FStar.Pervasives.delta))

:named typing_FStar.Pervasives.delta))

; </end encoding FStar.Pervasives.delta>


; <Start encoding FStar.Pervasives.zeta>

(declare-fun FStar.Pervasives.zeta (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.zeta; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(187,4-187,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(187,4-187,8)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.zeta @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.zeta @u0))
:qid typing_FStar.Pervasives.zeta))

:named typing_FStar.Pervasives.zeta))

; </end encoding FStar.Pervasives.zeta>


; <Start encoding FStar.Pervasives.zeta_full>

(declare-fun FStar.Pervasives.zeta_full (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.zeta_full; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(198,4-198,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(198,4-198,13)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.zeta_full @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.zeta_full @u0))
:qid typing_FStar.Pervasives.zeta_full))

:named typing_FStar.Pervasives.zeta_full))

; </end encoding FStar.Pervasives.zeta_full>


; <Start encoding FStar.Pervasives.iota>

(declare-fun FStar.Pervasives.iota (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.iota; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(201,4-201,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(201,4-201,8)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.iota @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.iota @u0))
:qid typing_FStar.Pervasives.iota))

:named typing_FStar.Pervasives.iota))

; </end encoding FStar.Pervasives.iota>


; <Start encoding FStar.Pervasives.nbe>

(declare-fun FStar.Pervasives.nbe (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.nbe; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(204,4-204,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(204,4-204,7)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.nbe @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.nbe @u0))
:qid typing_FStar.Pervasives.nbe))

:named typing_FStar.Pervasives.nbe))

; </end encoding FStar.Pervasives.nbe>


; <Start encoding FStar.Pervasives.reify_>

(declare-fun FStar.Pervasives.reify_ (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.reify_; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(207,4-207,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(207,4-207,10)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.reify_ @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.reify_ @u0))
:qid typing_FStar.Pervasives.reify_))

:named typing_FStar.Pervasives.reify_))

; </end encoding FStar.Pervasives.reify_>


; <Start encoding FStar.Pervasives.delta_only>

(declare-fun FStar.Pervasives.delta_only (Term) Term)
;;;;;;;;;;;;;;;;s: Prims.list Prims.string -> FStar.Pervasives.norm_step
(declare-fun Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1
;;; Fact-ids: Name FStar.Pervasives.delta_only; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1
Tm_type)
:named kinding_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.delta_only; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,38-211,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,38-211,47)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))

:named FStar.Pervasives_pre_typing_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1
;;; Fact-ids: Name FStar.Pervasives.delta_only; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,38-211,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,38-211,47)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,38-211,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,38-211,47)
(forall ((@x1 Term))
 (! (implies (HasType @x1
(Prims.list Prims.string))
(HasType (ApplyTT @x0
@x1)
FStar.Pervasives.norm_step))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))

:named FStar.Pervasives_interpretation_Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))
(declare-fun FStar.Pervasives.delta_only@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.delta_only; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_only@tok
@x0)
(FStar.Pervasives.delta_only @x0))
 

:pattern ((ApplyTT FStar.Pervasives.delta_only@tok
@x0))
:qid token_correspondence_FStar.Pervasives.delta_only))

:named token_correspondence_FStar.Pervasives.delta_only))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.delta_only; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.delta_only@tok
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_only@tok
@x1)
(FStar.Pervasives.delta_only @x1))
 

:pattern ((FStar.Pervasives.delta_only @x1))
:qid function_token_typing_FStar.Pervasives.delta_only.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.delta_only@tok))
:qid function_token_typing_FStar.Pervasives.delta_only))

:named function_token_typing_FStar.Pervasives.delta_only))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.delta_only; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(211,4-211,14)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.string))
(HasType (FStar.Pervasives.delta_only @x0)
FStar.Pervasives.norm_step))
 

:pattern ((FStar.Pervasives.delta_only @x0))
:qid typing_FStar.Pervasives.delta_only))

:named typing_FStar.Pervasives.delta_only))

; </end encoding FStar.Pervasives.delta_only>


; <Start encoding FStar.Pervasives.delta_fully>

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

(declare-fun FStar.Pervasives.delta_fully@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.delta_fully; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_fully@tok
@x0)
(FStar.Pervasives.delta_fully @x0))
 

:pattern ((ApplyTT FStar.Pervasives.delta_fully@tok
@x0))
:qid token_correspondence_FStar.Pervasives.delta_fully))

:named token_correspondence_FStar.Pervasives.delta_fully))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.delta_fully; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.delta_fully@tok
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_fully@tok
@x1)
(FStar.Pervasives.delta_fully @x1))
 

:pattern ((FStar.Pervasives.delta_fully @x1))
:qid function_token_typing_FStar.Pervasives.delta_fully.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.delta_fully@tok))
:qid function_token_typing_FStar.Pervasives.delta_fully))

:named function_token_typing_FStar.Pervasives.delta_fully))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.delta_fully; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(228,4-228,15)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.string))
(HasType (FStar.Pervasives.delta_fully @x0)
FStar.Pervasives.norm_step))
 

:pattern ((FStar.Pervasives.delta_fully @x0))
:qid typing_FStar.Pervasives.delta_fully))

:named typing_FStar.Pervasives.delta_fully))

; </end encoding FStar.Pervasives.delta_fully>


; <Start encoding FStar.Pervasives.delta_attr>

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

(declare-fun FStar.Pervasives.delta_attr@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.delta_attr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_attr@tok
@x0)
(FStar.Pervasives.delta_attr @x0))
 

:pattern ((ApplyTT FStar.Pervasives.delta_attr@tok
@x0))
:qid token_correspondence_FStar.Pervasives.delta_attr))

:named token_correspondence_FStar.Pervasives.delta_attr))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.delta_attr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.delta_attr@tok
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_attr@tok
@x1)
(FStar.Pervasives.delta_attr @x1))
 

:pattern ((FStar.Pervasives.delta_attr @x1))
:qid function_token_typing_FStar.Pervasives.delta_attr.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.delta_attr@tok))
:qid function_token_typing_FStar.Pervasives.delta_attr))

:named function_token_typing_FStar.Pervasives.delta_attr))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.delta_attr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(251,4-251,14)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.string))
(HasType (FStar.Pervasives.delta_attr @x0)
FStar.Pervasives.norm_step))
 

:pattern ((FStar.Pervasives.delta_attr @x0))
:qid typing_FStar.Pervasives.delta_attr))

:named typing_FStar.Pervasives.delta_attr))

; </end encoding FStar.Pervasives.delta_attr>


; <Start encoding FStar.Pervasives.delta_qualifier>

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

(declare-fun FStar.Pervasives.delta_qualifier@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.delta_qualifier; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_qualifier@tok
@x0)
(FStar.Pervasives.delta_qualifier @x0))
 

:pattern ((ApplyTT FStar.Pervasives.delta_qualifier@tok
@x0))
:qid token_correspondence_FStar.Pervasives.delta_qualifier))

:named token_correspondence_FStar.Pervasives.delta_qualifier))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.delta_qualifier; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.delta_qualifier@tok
Tm_arrow_f14a20345cd55ddda96b6c4cc49e05f1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.delta_qualifier@tok
@x1)
(FStar.Pervasives.delta_qualifier @x1))
 

:pattern ((FStar.Pervasives.delta_qualifier @x1))
:qid function_token_typing_FStar.Pervasives.delta_qualifier.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.delta_qualifier@tok))
:qid function_token_typing_FStar.Pervasives.delta_qualifier))

:named function_token_typing_FStar.Pervasives.delta_qualifier))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.delta_qualifier; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(270,4-270,19)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.string))
(HasType (FStar.Pervasives.delta_qualifier @x0)
FStar.Pervasives.norm_step))
 

:pattern ((FStar.Pervasives.delta_qualifier @x0))
:qid typing_FStar.Pervasives.delta_qualifier))

:named typing_FStar.Pervasives.delta_qualifier))

; </end encoding FStar.Pervasives.delta_qualifier>


; <Start encoding FStar.Pervasives.unmeta>

(declare-fun FStar.Pervasives.unmeta (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.unmeta; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(278,4-278,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(278,4-278,10)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.unmeta @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.unmeta @u0))
:qid typing_FStar.Pervasives.unmeta))

:named typing_FStar.Pervasives.unmeta))

; </end encoding FStar.Pervasives.unmeta>


; <Start encoding FStar.Pervasives.unascribe>

(declare-fun FStar.Pervasives.unascribe (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.unascribe; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(301,4-301,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(301,4-301,13)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.unascribe @u0)
FStar.Pervasives.norm_step)
 

:pattern ((FStar.Pervasives.unascribe @u0))
:qid typing_FStar.Pervasives.unascribe))

:named typing_FStar.Pervasives.unascribe))

; </end encoding FStar.Pervasives.unascribe>


; <Start encoding FStar.Pervasives.norm>

(declare-fun FStar.Pervasives.norm (Term Term Term) Term)
;;;;;;;;;;;;;;;;s: Prims.list FStar.Pervasives.norm_step -> x: a -> a
(declare-fun Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea
;;; Fact-ids: Name FStar.Pervasives.norm; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea
Tm_type)
:named kinding_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,31-305,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,53-305,54)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))
:qid FStar.Pervasives_pre_typing_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))

:named FStar.Pervasives_pre_typing_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea
;;; Fact-ids: Name FStar.Pervasives.norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,31-305,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,53-305,54)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,31-305,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,53-305,54)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
(Prims.list FStar.Pervasives.norm_step))
(HasType @x2
Tm_type)
(HasType @x3
@x2))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,31-305,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,53-305,54)
(forall ((@x1 Term))
 (! (implies (HasType @x1
(Prims.list FStar.Pervasives.norm_step))
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,31-305,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,53-305,54)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
(Prims.list FStar.Pervasives.norm_step))
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))
:qid FStar.Pervasives_interpretation_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))

:named FStar.Pervasives_interpretation_Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))
(declare-fun FStar.Pervasives.norm@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.norm@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.norm @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.norm@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.norm))

:named token_correspondence_FStar.Pervasives.norm))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.norm@tok
Tm_arrow_7d92e7a4aa7eee4098b10c5f1b3d77ea))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.norm@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.norm @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.norm @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.norm.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.norm@tok))
:qid function_token_typing_FStar.Pervasives.norm))

:named function_token_typing_FStar.Pervasives.norm))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(305,4-305,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
(Prims.list FStar.Pervasives.norm_step))
(HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (FStar.Pervasives.norm @x0
@x1
@x2)
@x1))
 

:pattern ((FStar.Pervasives.norm @x0
@x1
@x2))
:qid typing_FStar.Pervasives.norm))

:named typing_FStar.Pervasives.norm))

; </end encoding FStar.Pervasives.norm>


; <Start encoding FStar.Pervasives.assert_norm>

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

;;;;;;;;;;;;;;;;p: Type -> Prims.Pure Prims.unit
(declare-fun Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb
;;; Fact-ids: Name FStar.Pervasives.assert_norm; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb
Tm_type)
:named kinding_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.assert_norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,33-309,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,33-309,37)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))

:named FStar.Pervasives_pre_typing_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb
;;; Fact-ids: Name FStar.Pervasives.assert_norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,33-309,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,33-309,37)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,33-309,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,33-309,37)
(forall ((@x1 Term))
 (! (implies (and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,17-309,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,59-309,60)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,17-309,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,59-309,60)
@x1
)

(HasType @x1
Tm_type))
(HasType (ApplyTT @x0
@x1)
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))

:named FStar.Pervasives_interpretation_Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))
(declare-fun FStar.Pervasives.assert_norm@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.assert_norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.assert_norm@tok
@x0)
(FStar.Pervasives.assert_norm @x0))
 

:pattern ((ApplyTT FStar.Pervasives.assert_norm@tok
@x0))
:qid token_correspondence_FStar.Pervasives.assert_norm))

:named token_correspondence_FStar.Pervasives.assert_norm))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.assert_norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.assert_norm@tok
Tm_arrow_ee24fcf624d074d3c637ee61e4a867fb))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.assert_norm@tok
@x1)
(FStar.Pervasives.assert_norm @x1))
 

:pattern ((FStar.Pervasives.assert_norm @x1))
:qid function_token_typing_FStar.Pervasives.assert_norm.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.assert_norm@tok))
:qid function_token_typing_FStar.Pervasives.assert_norm))

:named function_token_typing_FStar.Pervasives.assert_norm))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.assert_norm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,4-309,15)
(forall ((@x0 Term))
 (! (implies (and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,17-309,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,59-309,60)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,17-309,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(309,59-309,60)
@x0
)

(HasType @x0
Tm_type))
(HasType (FStar.Pervasives.assert_norm @x0)
(Tm_refine_2de20c066034c13bf76e9c0b94f4806c @x0)))
 

:pattern ((FStar.Pervasives.assert_norm @x0))
:qid typing_FStar.Pervasives.assert_norm))

:named typing_FStar.Pervasives.assert_norm))

; </end encoding FStar.Pervasives.assert_norm>


; <Start encoding 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 FStar.Pervasives.normalize_term_spec>


; <Start encoding 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 FStar.Pervasives.normalize_spec>


; <Start encoding 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 FStar.Pervasives.norm_spec>


; <Start encoding FStar.Pervasives.reveal_opaque>

(declare-fun FStar.Pervasives.reveal_opaque (Term) Term)
(declare-fun Tm_refine_9cce35912d99bf51042f02fff62b6cf5 (Term Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x0
@x1
@x2)
Tm_type))
:qid refinement_kinding_Tm_refine_9cce35912d99bf51042f02fff62b6cf5))

:named refinement_kinding_Tm_refine_9cce35912d99bf51042f02fff62b6cf5))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x2
@x3
@x4))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(630,71-630,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(not 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,29-428,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,60-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(= (FStar.Pervasives.norm (Prims.Cons FStar.Pervasives.norm_step
(FStar.Pervasives.delta_only (Prims.Cons Prims.string
@x2
(Prims.Nil Prims.string)))
(Prims.Nil FStar.Pervasives.norm_step))
@x3
@x4)
@x4)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(630,86-630,95); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(not 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(630,86-630,95); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(= @x5
@x1)
)
)
 
;;no pats
:qid refinement_interpretation_Tm_refine_9cce35912d99bf51042f02fff62b6cf5.1))
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x2
@x3
@x4)))
:qid refinement_interpretation_Tm_refine_9cce35912d99bf51042f02fff62b6cf5))

:named refinement_interpretation_Tm_refine_9cce35912d99bf51042f02fff62b6cf5))
;;;;;;;;;;;;;;;;haseq for Tm_refine_9cce35912d99bf51042f02fff62b6cf5
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x0
@x1
@x2)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x0
@x1
@x2))))
:qid haseqTm_refine_9cce35912d99bf51042f02fff62b6cf5))

:named haseqTm_refine_9cce35912d99bf51042f02fff62b6cf5))
;;;;;;;;;;;;;;;;x: a   -> FStar.Pervasives.Lemma (ensures FStar.Pervasives.norm [FStar.Pervasives.delta_only [s]] x == x)
(declare-fun Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x0)
Tm_type))
:qid kinding_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428))

:named kinding_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x2)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428))

:named FStar.Pervasives_pre_typing_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Tm_type)
(HasType @x3
@x2))
(HasType (ApplyTT (ApplyTT @x0
@x2)
@x3)
(Tm_refine_9cce35912d99bf51042f02fff62b6cf5 @x1
@x2
@x3)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Tm_type)
(IsTotFun (ApplyTT @x0
@x2)))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x1)))
:qid FStar.Pervasives_interpretation_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428))

:named FStar.Pervasives_interpretation_Tm_arrow_4857840526ebc56c0ecdc9a357ac7428))
;;;;;;;;;;;;;;;;s: Prims.string -> x: a   -> FStar.Pervasives.Lemma (ensures FStar.Pervasives.norm [FStar.Pervasives.delta_only [s]] x == x)
(declare-fun Tm_arrow_23a28adbf46ddeb7dd67342a2348b587 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_23a28adbf46ddeb7dd67342a2348b587
Tm_type)
:named kinding_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_23a28adbf46ddeb7dd67342a2348b587)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))
:qid FStar.Pervasives_pre_typing_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))

:named FStar.Pervasives_pre_typing_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_23a28adbf46ddeb7dd67342a2348b587)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(319,54-319,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,32-323,41)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.string)
(HasType (ApplyTT @x0
@x1)
(Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))
:qid FStar.Pervasives_interpretation_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))

:named FStar.Pervasives_interpretation_Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))
(declare-fun FStar.Pervasives.reveal_opaque@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.reveal_opaque@tok
@x0)
(FStar.Pervasives.reveal_opaque @x0))
 

:pattern ((ApplyTT FStar.Pervasives.reveal_opaque@tok
@x0))
:qid token_correspondence_FStar.Pervasives.reveal_opaque))

:named token_correspondence_FStar.Pervasives.reveal_opaque))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.reveal_opaque@tok
Tm_arrow_23a28adbf46ddeb7dd67342a2348b587))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.reveal_opaque@tok
@x1)
(FStar.Pervasives.reveal_opaque @x1))
 

:pattern ((FStar.Pervasives.reveal_opaque @x1))
:qid function_token_typing_FStar.Pervasives.reveal_opaque.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.reveal_opaque@tok))
:qid function_token_typing_FStar.Pervasives.reveal_opaque))

:named function_token_typing_FStar.Pervasives.reveal_opaque))


;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (FStar.Pervasives.reveal_opaque @x0)
(Tm_arrow_4857840526ebc56c0ecdc9a357ac7428 @x0)))
 

:pattern ((FStar.Pervasives.reveal_opaque @x0))
:qid typing_FStar.Pervasives.reveal_opaque))

:named typing_FStar.Pervasives.reveal_opaque))
;;;;;;;;;;;;;;;;kick_partial_app
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! (Valid (ApplyTT __uu__PartialApp
FStar.Pervasives.norm_spec@tok))
:named @kick_partial_app_e5c933a9bc2cb06571c2abdcc101b877))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.reveal_opaque
;;; Fact-ids: Name FStar.Pervasives.reveal_opaque; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(323,4-323,17)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.reveal_opaque @x0)
(ApplyTT FStar.Pervasives.norm_spec@tok
(Prims.Cons FStar.Pervasives.norm_step
(FStar.Pervasives.delta_only (Prims.Cons Prims.string
@x0
(Prims.Nil Prims.string)))
(Prims.Nil FStar.Pervasives.norm_step))))
 

:pattern ((FStar.Pervasives.reveal_opaque @x0))
:qid equation_FStar.Pervasives.reveal_opaque))

:named equation_FStar.Pervasives.reveal_opaque))

; </end encoding FStar.Pervasives.reveal_opaque>


; <Start encoding FStar.Pervasives.pure_return>

(declare-fun FStar.Pervasives.pure_return (Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> x: a -> Prims.pure_wp a
(declare-fun Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f
Tm_type)
:named kinding_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))
:qid FStar.Pervasives_pre_typing_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))

:named FStar.Pervasives_pre_typing_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,33-329,42)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))
:qid FStar.Pervasives_interpretation_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))

:named FStar.Pervasives_interpretation_Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))
(declare-fun FStar.Pervasives.pure_return@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.pure_return@tok
@x0)
@x1)
(FStar.Pervasives.pure_return @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.pure_return@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.pure_return))

:named token_correspondence_FStar.Pervasives.pure_return))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_return@tok
Tm_arrow_0dff8d294aeaf0b1d7e9cad664c9a15f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.pure_return@tok
@x1)
@x2)
(FStar.Pervasives.pure_return @x1
@x2))
 

:pattern ((FStar.Pervasives.pure_return @x1
@x2))
:qid function_token_typing_FStar.Pervasives.pure_return.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_return@tok))
:qid function_token_typing_FStar.Pervasives.pure_return))

:named function_token_typing_FStar.Pervasives.pure_return))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.pure_return @x0
@x1)
(Prims.pure_wp @x0)))
 

:pattern ((FStar.Pervasives.pure_return @x0
@x1))
:qid typing_FStar.Pervasives.pure_return))

:named typing_FStar.Pervasives.pure_return))

(declare-fun Tm_abs_bc5117f6a06a581c69e04141781c86d0 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_bc5117f6a06a581c69e04141781c86d0
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x0
@x1
@x2)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2))
 

:pattern ((Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x0
@x1
@x2))
:qid typing_Tm_abs_bc5117f6a06a581c69e04141781c86d0))

:named typing_Tm_abs_bc5117f6a06a581c69e04141781c86d0))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_bc5117f6a06a581c69e04141781c86d0
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x1
@x2
@x3)
@x0)
(Prims.l_imp (Prims.eq2 @x3
@x0
@x1)
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_bc5117f6a06a581c69e04141781c86d0))

:named interpretation_Tm_abs_bc5117f6a06a581c69e04141781c86d0))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall @x2
(Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,26-343,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(= @x3
@x1)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,46-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,46-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(ApplyTT @x0
@x3)
)
)
 
;;no pats
:qid l_quant_interp_904a74cfe3507104488fdcb4d014247a.1))
)
 

:pattern ((Valid (Prims.l_Forall @x2
(Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x1
@x0
@x2))))
:qid l_quant_interp_904a74cfe3507104488fdcb4d014247a))

:named l_quant_interp_904a74cfe3507104488fdcb4d014247a))
;;;;;;;;;;;;;;;;p: Prims.pure_post a -> Prims.logical
(declare-fun Tm_arrow_c88a29758356586fc450d481d4b685f3 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c88a29758356586fc450d481d4b685f3
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_c88a29758356586fc450d481d4b685f3 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_c88a29758356586fc450d481d4b685f3 @x0)
Tm_type))
:qid kinding_Tm_arrow_c88a29758356586fc450d481d4b685f3))

:named kinding_Tm_arrow_c88a29758356586fc450d481d4b685f3))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x2)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_c88a29758356586fc450d481d4b685f3))

:named FStar.Pervasives_pre_typing_Tm_arrow_c88a29758356586fc450d481d4b685f3))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c88a29758356586fc450d481d4b685f3
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(Prims.pure_post @x1))
(HasType (ApplyTT @x0
@x2)
Prims.logical))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_c88a29758356586fc450d481d4b685f3.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x1)))
:qid FStar.Pervasives_interpretation_Tm_arrow_c88a29758356586fc450d481d4b685f3))

:named FStar.Pervasives_interpretation_Tm_arrow_c88a29758356586fc450d481d4b685f3))
(declare-fun Tm_abs_bdac9a3f32789788b83138a3a4262d0d (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_bdac9a3f32789788b83138a3a4262d0d
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_bdac9a3f32789788b83138a3a4262d0d @x0
@x1)
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x1))
 

:pattern ((Tm_abs_bdac9a3f32789788b83138a3a4262d0d @x0
@x1))
:qid typing_Tm_abs_bdac9a3f32789788b83138a3a4262d0d))

:named typing_Tm_abs_bdac9a3f32789788b83138a3a4262d0d))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_bdac9a3f32789788b83138a3a4262d0d
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(331,2-331,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_bdac9a3f32789788b83138a3a4262d0d @x1
@x2)
@x0)
(Prims.l_Forall @x2
(Tm_abs_bc5117f6a06a581c69e04141781c86d0 @x1
@x0
@x2)))
 

:pattern ((ApplyTT (Tm_abs_bdac9a3f32789788b83138a3a4262d0d @x1
@x2)
@x0))
:qid interpretation_Tm_abs_bdac9a3f32789788b83138a3a4262d0d))

:named interpretation_Tm_abs_bdac9a3f32789788b83138a3a4262d0d))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pure_return
;;; Fact-ids: Name FStar.Pervasives.pure_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(329,4-329,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.pure_return @x0
@x1)
(Tm_abs_bdac9a3f32789788b83138a3a4262d0d @x1
@x0))
 

:pattern ((FStar.Pervasives.pure_return @x0
@x1))
:qid equation_FStar.Pervasives.pure_return))

:named equation_FStar.Pervasives.pure_return))

; </end encoding FStar.Pervasives.pure_return>


; <Start encoding FStar.Pervasives.pure_bind_wp>

;;;;;;;;;;;;;;;;_: a -> Prims.pure_wp b
(declare-fun Tm_arrow_c05bc9331677cc1a187ad7677301a601 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c05bc9331677cc1a187ad7677301a601
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_c05bc9331677cc1a187ad7677301a601))

:named kinding_Tm_arrow_c05bc9331677cc1a187ad7677301a601))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_c05bc9331677cc1a187ad7677301a601))

:named FStar.Pervasives_pre_typing_Tm_arrow_c05bc9331677cc1a187ad7677301a601))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c05bc9331677cc1a187ad7677301a601
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,59-334,70)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(HasType (ApplyTT @x0
@x3)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_c05bc9331677cc1a187ad7677301a601.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_c05bc9331677cc1a187ad7677301a601))

:named FStar.Pervasives_interpretation_Tm_arrow_c05bc9331677cc1a187ad7677301a601))
(declare-fun FStar.Pervasives.pure_bind_wp (Term Term Term Term) Term)

;;;;;;;;;;;;;;;;a: Type -> b: Type -> wp1: Prims.pure_wp a -> wp2: (_: a -> Prims.pure_wp b) -> Prims.pure_wp b
(declare-fun Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e
Tm_type)
:named kinding_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))

:named FStar.Pervasives_pre_typing_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pure_wp @x1))
(HasType @x4
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Prims.pure_wp @x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,79-334,90)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pure_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))

:named FStar.Pervasives_interpretation_Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))
(declare-fun FStar.Pervasives.pure_bind_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.pure_bind_wp @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_bind_wp@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.pure_bind_wp))

:named token_correspondence_FStar.Pervasives.pure_bind_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_bind_wp@tok
Tm_arrow_f8eba41a4bcb9aca0e3c11224f695d1e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_bind_wp@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.pure_bind_wp @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.pure_bind_wp @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.pure_bind_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_bind_wp@tok))
:qid function_token_typing_FStar.Pervasives.pure_bind_wp))

:named function_token_typing_FStar.Pervasives.pure_bind_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.pure_wp @x0))
(HasType @x3
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x1
@x0)))
(HasType (FStar.Pervasives.pure_bind_wp @x0
@x1
@x2
@x3)
(Prims.pure_wp @x1)))
 

:pattern ((FStar.Pervasives.pure_bind_wp @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.pure_bind_wp))

:named typing_FStar.Pervasives.pure_bind_wp))


(declare-fun Tm_abs_d0f415a5361a9d7988d8e425dc193472 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_d0f415a5361a9d7988d8e425dc193472
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(356,38-356,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(336,2-336,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x0
@x1
@x2)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2))
 

:pattern ((Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x0
@x1
@x2))
:qid typing_Tm_abs_d0f415a5361a9d7988d8e425dc193472))

:named typing_Tm_abs_d0f415a5361a9d7988d8e425dc193472))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_d0f415a5361a9d7988d8e425dc193472
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(356,38-356,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(336,2-336,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x1
@x2
@x3)
@x0)
(ApplyTT (ApplyTT @x1
@x0)
@x2))
 

:pattern ((ApplyTT (Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_d0f415a5361a9d7988d8e425dc193472))

:named interpretation_Tm_abs_d0f415a5361a9d7988d8e425dc193472))

(declare-fun Tm_abs_72b65b71b828688dbb0ba657715a194c (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_72b65b71b828688dbb0ba657715a194c
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(356,7-356,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(336,2-336,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_72b65b71b828688dbb0ba657715a194c @x0
@x1
@x2
@x3)
(Tm_arrow_e5c03abbf8b0946a9aa7ee31bb7999a4 @x3))
 

:pattern ((Tm_abs_72b65b71b828688dbb0ba657715a194c @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_72b65b71b828688dbb0ba657715a194c))

:named typing_Tm_abs_72b65b71b828688dbb0ba657715a194c))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_72b65b71b828688dbb0ba657715a194c
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(356,7-356,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(336,2-336,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_72b65b71b828688dbb0ba657715a194c @x1
@x2
@x3
@x4)
@x0)
(ApplyTT @x1
(Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x2
@x0
@x3)))
 

:pattern ((ApplyTT (Tm_abs_72b65b71b828688dbb0ba657715a194c @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_72b65b71b828688dbb0ba657715a194c))

:named interpretation_Tm_abs_72b65b71b828688dbb0ba657715a194c))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pure_bind_wp
;;; Fact-ids: Name FStar.Pervasives.pure_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(334,4-334,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.pure_bind_wp @x0
@x1
@x2
@x3)
(Tm_abs_72b65b71b828688dbb0ba657715a194c @x2
@x3
@x0
@x1))
 

:pattern ((FStar.Pervasives.pure_bind_wp @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.pure_bind_wp))

:named equation_FStar.Pervasives.pure_bind_wp))

; </end encoding FStar.Pervasives.pure_bind_wp>


; <Start encoding FStar.Pervasives.pure_if_then_else>

(declare-fun FStar.Pervasives.pure_if_then_else (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> p: Type -> wp_then: Prims.pure_wp a -> wp_else: Prims.pure_wp a -> Prims.pure_wp a
(declare-fun Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea
Tm_type)
:named kinding_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))
:qid FStar.Pervasives_pre_typing_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))

:named FStar.Pervasives_pre_typing_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pure_wp @x1))
(HasType @x4
(Prims.pure_wp @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,67-339,78)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Prims.pure_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))
:qid FStar.Pervasives_interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))

:named FStar.Pervasives_interpretation_Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))
(declare-fun FStar.Pervasives.pure_if_then_else@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.pure_if_then_else @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_if_then_else@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.pure_if_then_else))

:named token_correspondence_FStar.Pervasives.pure_if_then_else))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_if_then_else@tok
Tm_arrow_5911c11ab85061b4a8acf6a6ff43aaea))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_if_then_else@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.pure_if_then_else @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.pure_if_then_else @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.pure_if_then_else.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_if_then_else@tok))
:qid function_token_typing_FStar.Pervasives.pure_if_then_else))

:named function_token_typing_FStar.Pervasives.pure_if_then_else))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Prims.pure_wp @x0))
(HasType @x3
(Prims.pure_wp @x0)))
(HasType (FStar.Pervasives.pure_if_then_else @x0
@x1
@x2
@x3)
(Prims.pure_wp @x0)))
 

:pattern ((FStar.Pervasives.pure_if_then_else @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.pure_if_then_else))

:named typing_FStar.Pervasives.pure_if_then_else))

(declare-fun Tm_abs_614d7ab3976dfea6b6428085a93bafcc (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_614d7ab3976dfea6b6428085a93bafcc
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(376,2-376,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(341,2-341,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_614d7ab3976dfea6b6428085a93bafcc @x0
@x1
@x2
@x3)
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x3))
 

:pattern ((Tm_abs_614d7ab3976dfea6b6428085a93bafcc @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_614d7ab3976dfea6b6428085a93bafcc))

:named typing_Tm_abs_614d7ab3976dfea6b6428085a93bafcc))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_614d7ab3976dfea6b6428085a93bafcc
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(376,2-376,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(341,2-341,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_614d7ab3976dfea6b6428085a93bafcc @x1
@x2
@x3
@x4)
@x0)
(Prims.l_and (ApplyTT @x1
@x0)
(Prims.l_imp (Prims.l_not @x2)
(ApplyTT @x3
@x0))))
 

:pattern ((ApplyTT (Tm_abs_614d7ab3976dfea6b6428085a93bafcc @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_614d7ab3976dfea6b6428085a93bafcc))

:named interpretation_Tm_abs_614d7ab3976dfea6b6428085a93bafcc))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pure_if_then_else
;;; Fact-ids: Name FStar.Pervasives.pure_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(339,4-339,21)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.pure_if_then_else @x0
@x1
@x2
@x3)
(Tm_abs_614d7ab3976dfea6b6428085a93bafcc @x2
@x1
@x3
@x0))
 

:pattern ((FStar.Pervasives.pure_if_then_else @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.pure_if_then_else))

:named equation_FStar.Pervasives.pure_if_then_else))

; </end encoding FStar.Pervasives.pure_if_then_else>


; <Start encoding FStar.Pervasives.pure_ite_wp>

(declare-fun FStar.Pervasives.pure_ite_wp (Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> wp: Prims.pure_wp a -> Prims.pure_wp a
(declare-fun Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8
Tm_type)
:named kinding_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))
:qid FStar.Pervasives_pre_typing_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))

:named FStar.Pervasives_pre_typing_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Prims.pure_wp @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,46-344,57)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))
:qid FStar.Pervasives_interpretation_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))

:named FStar.Pervasives_interpretation_Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))
(declare-fun FStar.Pervasives.pure_ite_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.pure_ite_wp@tok
@x0)
@x1)
(FStar.Pervasives.pure_ite_wp @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.pure_ite_wp@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.pure_ite_wp))

:named token_correspondence_FStar.Pervasives.pure_ite_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_ite_wp@tok
Tm_arrow_983cc9c1e881fffd3b37c61b327d54c8))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.pure_ite_wp@tok
@x1)
@x2)
(FStar.Pervasives.pure_ite_wp @x1
@x2))
 

:pattern ((FStar.Pervasives.pure_ite_wp @x1
@x2))
:qid function_token_typing_FStar.Pervasives.pure_ite_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_ite_wp@tok))
:qid function_token_typing_FStar.Pervasives.pure_ite_wp))

:named function_token_typing_FStar.Pervasives.pure_ite_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Prims.pure_wp @x0)))
(HasType (FStar.Pervasives.pure_ite_wp @x0
@x1)
(Prims.pure_wp @x0)))
 

:pattern ((FStar.Pervasives.pure_ite_wp @x0
@x1))
:qid typing_FStar.Pervasives.pure_ite_wp))

:named typing_FStar.Pervasives.pure_ite_wp))




(declare-fun Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x0
@x1
@x2)
(Tm_arrow_b275e247a67e3e77d7c5997d864d1247 @x2))
 

:pattern ((Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x0
@x1
@x2))
:qid typing_Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c))

:named typing_Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x1
@x2
@x3)
@x0)
(Prims.l_imp (Prims.l_Forall @x3
(Tm_abs_ea1703a99385b474600aa7a3bdb045c5 @x1
@x0
@x3))
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c))

:named interpretation_Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall (Prims.pure_post @x2)
(Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
(Prims.pure_post @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,27-389,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x4 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,73-389,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,73-389,79); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,73-389,79); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(ApplyTT @x1
@x4)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,84-389,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,84-389,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(ApplyTT @x3
@x4)
)
)

 

:pattern ((ApplyTT @x3
@x4))
:qid l_quant_interp_85425e4b8be41742de1008493fc10ad5.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,93-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,93-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(ApplyTT @x0
@x3)
)
)
 
;;no pats
:qid l_quant_interp_85425e4b8be41742de1008493fc10ad5.1))
)
 

:pattern ((Valid (Prims.l_Forall (Prims.pure_post @x2)
(Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x1
@x0
@x2))))
:qid l_quant_interp_85425e4b8be41742de1008493fc10ad5))

:named l_quant_interp_85425e4b8be41742de1008493fc10ad5))

(declare-fun Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d @x0
@x1)
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x1))
 

:pattern ((Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d @x0
@x1))
:qid typing_Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d))

:named typing_Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(346,2-346,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d @x1
@x2)
@x0)
(Prims.l_Forall (Prims.pure_post @x2)
(Tm_abs_f9993abe3e10fc5902262cf22e5f5e1c @x0
@x1
@x2)))
 

:pattern ((ApplyTT (Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d @x1
@x2)
@x0))
:qid interpretation_Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d))

:named interpretation_Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pure_ite_wp
;;; Fact-ids: Name FStar.Pervasives.pure_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(344,4-344,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.pure_ite_wp @x0
@x1)
(Tm_abs_a4d8a67e708eb0f8e41d6eefd90d8b3d @x1
@x0))
 

:pattern ((FStar.Pervasives.pure_ite_wp @x0
@x1))
:qid equation_FStar.Pervasives.pure_ite_wp))

:named equation_FStar.Pervasives.pure_ite_wp))

; </end encoding FStar.Pervasives.pure_ite_wp>


; <Start encoding FStar.Pervasives.pure_close_wp>


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

;;;;;;;;;;;;;;;;a: Type -> b: Type -> wp: (_: b -> Prims.pure_wp a) -> Prims.pure_wp a
(declare-fun Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78
Tm_type)
:named kinding_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))
:qid FStar.Pervasives_pre_typing_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))

:named FStar.Pervasives_pre_typing_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,61-349,72)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))
:qid FStar.Pervasives_interpretation_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))

:named FStar.Pervasives_interpretation_Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))
(declare-fun FStar.Pervasives.pure_close_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_close_wp@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.pure_close_wp @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_close_wp@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.pure_close_wp))

:named token_correspondence_FStar.Pervasives.pure_close_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_close_wp@tok
Tm_arrow_6424f17922e38fc8eb3b7ad8d9107d78))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.pure_close_wp@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.pure_close_wp @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.pure_close_wp @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.pure_close_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_close_wp@tok))
:qid function_token_typing_FStar.Pervasives.pure_close_wp))

:named function_token_typing_FStar.Pervasives.pure_close_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_c05bc9331677cc1a187ad7677301a601 @x0
@x1)))
(HasType (FStar.Pervasives.pure_close_wp @x0
@x1
@x2)
(Prims.pure_wp @x0)))
 

:pattern ((FStar.Pervasives.pure_close_wp @x0
@x1
@x2))
:qid typing_FStar.Pervasives.pure_close_wp))

:named typing_FStar.Pervasives.pure_close_wp))



;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(400,99-400,120); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(351,2-351,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall @x2
(Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(400,99-400,120); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(351,2-351,16)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(400,114-400,120); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(351,2-351,16)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(400,114-400,120); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(351,2-351,16)
(ApplyTT (ApplyTT @x1
@x3)
@x0)
)
)
 
;;no pats
:qid l_quant_interp_0b1b710a8bfdc3d62549685b3ad0a6b3.1))
)
 

:pattern ((Valid (Prims.l_Forall @x2
(Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x1
@x0
@x2))))
:qid l_quant_interp_0b1b710a8bfdc3d62549685b3ad0a6b3))

:named l_quant_interp_0b1b710a8bfdc3d62549685b3ad0a6b3))

(declare-fun Tm_abs_bef01cdc202d648a37f7725a1e8579fa (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_bef01cdc202d648a37f7725a1e8579fa
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(400,99-400,120); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(351,2-351,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_bef01cdc202d648a37f7725a1e8579fa @x0
@x1
@x2)
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x2))
 

:pattern ((Tm_abs_bef01cdc202d648a37f7725a1e8579fa @x0
@x1
@x2))
:qid typing_Tm_abs_bef01cdc202d648a37f7725a1e8579fa))

:named typing_Tm_abs_bef01cdc202d648a37f7725a1e8579fa))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_bef01cdc202d648a37f7725a1e8579fa
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(400,99-400,120); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(351,2-351,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_bef01cdc202d648a37f7725a1e8579fa @x1
@x2
@x3)
@x0)
(Prims.l_Forall @x1
(Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x2
@x0
@x1)))
 

:pattern ((ApplyTT (Tm_abs_bef01cdc202d648a37f7725a1e8579fa @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_bef01cdc202d648a37f7725a1e8579fa))

:named interpretation_Tm_abs_bef01cdc202d648a37f7725a1e8579fa))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pure_close_wp
;;; Fact-ids: Name FStar.Pervasives.pure_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(349,4-349,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.pure_close_wp @x0
@x1
@x2)
(Tm_abs_bef01cdc202d648a37f7725a1e8579fa @x1
@x2
@x0))
 

:pattern ((FStar.Pervasives.pure_close_wp @x0
@x1
@x2))
:qid equation_FStar.Pervasives.pure_close_wp))

:named equation_FStar.Pervasives.pure_close_wp))

; </end encoding FStar.Pervasives.pure_close_wp>


; <Start encoding FStar.Pervasives.pure_null_wp>

(declare-fun FStar.Pervasives.pure_null_wp (Term) Term)
;;;;;;;;;;;;;;;;a: Type -> Prims.pure_wp a
(declare-fun Tm_arrow_e02f472dad10492b4fdaf21971ae643f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e02f472dad10492b4fdaf21971ae643f
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_e02f472dad10492b4fdaf21971ae643f
Tm_type)
:named kinding_Tm_arrow_e02f472dad10492b4fdaf21971ae643f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,32-354,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,32-354,43)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e02f472dad10492b4fdaf21971ae643f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e02f472dad10492b4fdaf21971ae643f))
:qid FStar.Pervasives_pre_typing_Tm_arrow_e02f472dad10492b4fdaf21971ae643f))

:named FStar.Pervasives_pre_typing_Tm_arrow_e02f472dad10492b4fdaf21971ae643f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e02f472dad10492b4fdaf21971ae643f
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,32-354,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,32-354,43)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e02f472dad10492b4fdaf21971ae643f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,32-354,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,32-354,43)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_e02f472dad10492b4fdaf21971ae643f.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e02f472dad10492b4fdaf21971ae643f))
:qid FStar.Pervasives_interpretation_Tm_arrow_e02f472dad10492b4fdaf21971ae643f))

:named FStar.Pervasives_interpretation_Tm_arrow_e02f472dad10492b4fdaf21971ae643f))
(declare-fun FStar.Pervasives.pure_null_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.pure_null_wp@tok
@x0)
(FStar.Pervasives.pure_null_wp @x0))
 

:pattern ((ApplyTT FStar.Pervasives.pure_null_wp@tok
@x0))
:qid token_correspondence_FStar.Pervasives.pure_null_wp))

:named token_correspondence_FStar.Pervasives.pure_null_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_null_wp@tok
Tm_arrow_e02f472dad10492b4fdaf21971ae643f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.pure_null_wp@tok
@x1)
(FStar.Pervasives.pure_null_wp @x1))
 

:pattern ((FStar.Pervasives.pure_null_wp @x1))
:qid function_token_typing_FStar.Pervasives.pure_null_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_null_wp@tok))
:qid function_token_typing_FStar.Pervasives.pure_null_wp))

:named function_token_typing_FStar.Pervasives.pure_null_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.pure_null_wp @x0)
(Prims.pure_wp @x0)))
 

:pattern ((FStar.Pervasives.pure_null_wp @x0))
:qid typing_FStar.Pervasives.pure_null_wp))

:named typing_FStar.Pervasives.pure_null_wp))


;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(356,2-356,15)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.l_Forall @x1
(Tm_abs_6ba36691ee58dee85cd144324b083848 @x0
@x1)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(356,2-356,15)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@x1)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,90-438,102); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(356,2-356,15)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,90-438,102); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(356,2-356,15)
(ApplyTT @x0
@x2)
)
)
 
;;no pats
:qid l_quant_interp_b318409532d0e00e9125f72f3b997468.1))
)
 

:pattern ((Valid (Prims.l_Forall @x1
(Tm_abs_6ba36691ee58dee85cd144324b083848 @x0
@x1))))
:qid l_quant_interp_b318409532d0e00e9125f72f3b997468))

:named l_quant_interp_b318409532d0e00e9125f72f3b997468))

(declare-fun Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 (Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_c7a599bd05f6d553477b7b3a5a51d357
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(356,2-356,15)
(forall ((@x0 Term))
 (! (HasType (Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 @x0)
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x0))
 

:pattern ((Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 @x0))
:qid typing_Tm_abs_c7a599bd05f6d553477b7b3a5a51d357))

:named typing_Tm_abs_c7a599bd05f6d553477b7b3a5a51d357))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_c7a599bd05f6d553477b7b3a5a51d357
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(356,2-356,15)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 @x1)
@x0)
(Prims.l_Forall @x1
(Tm_abs_6ba36691ee58dee85cd144324b083848 @x0
@x1)))
 

:pattern ((ApplyTT (Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 @x1)
@x0))
:qid interpretation_Tm_abs_c7a599bd05f6d553477b7b3a5a51d357))

:named interpretation_Tm_abs_c7a599bd05f6d553477b7b3a5a51d357))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.pure_null_wp
;;; Fact-ids: Name FStar.Pervasives.pure_null_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(354,4-354,16)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.pure_null_wp @x0)
(Tm_abs_c7a599bd05f6d553477b7b3a5a51d357 @x0))
 

:pattern ((FStar.Pervasives.pure_null_wp @x0))
:qid equation_FStar.Pervasives.pure_null_wp))

:named equation_FStar.Pervasives.pure_null_wp))

; </end encoding FStar.Pervasives.pure_null_wp>


; <Start encoding FStar.Pervasives.pure_assert_wp>

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

(declare-fun FStar.Pervasives.pure_assert_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_assert_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.pure_assert_wp@tok
@x0)
(FStar.Pervasives.pure_assert_wp @x0))
 

:pattern ((ApplyTT FStar.Pervasives.pure_assert_wp@tok
@x0))
:qid token_correspondence_FStar.Pervasives.pure_assert_wp))

:named token_correspondence_FStar.Pervasives.pure_assert_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_assert_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_assert_wp@tok
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.pure_assert_wp@tok
@x1)
(FStar.Pervasives.pure_assert_wp @x1))
 

:pattern ((FStar.Pervasives.pure_assert_wp @x1))
:qid function_token_typing_FStar.Pervasives.pure_assert_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_assert_wp@tok))
:qid function_token_typing_FStar.Pervasives.pure_assert_wp))

:named function_token_typing_FStar.Pervasives.pure_assert_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_assert_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(360,4-360,18)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.pure_assert_wp @x0)
(Prims.pure_wp Prims.unit)))
 

:pattern ((FStar.Pervasives.pure_assert_wp @x0))
:qid typing_FStar.Pervasives.pure_assert_wp))

:named typing_FStar.Pervasives.pure_assert_wp))

; </end encoding FStar.Pervasives.pure_assert_wp>


; <Start encoding FStar.Pervasives.pure_assume_wp>

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

(declare-fun FStar.Pervasives.pure_assume_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.pure_assume_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.pure_assume_wp@tok
@x0)
(FStar.Pervasives.pure_assume_wp @x0))
 

:pattern ((ApplyTT FStar.Pervasives.pure_assume_wp@tok
@x0))
:qid token_correspondence_FStar.Pervasives.pure_assume_wp))

:named token_correspondence_FStar.Pervasives.pure_assume_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.pure_assume_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.pure_assume_wp@tok
Tm_arrow_14bcf5e7fc38d91827ecd9d25d3b3a67))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.pure_assume_wp@tok
@x1)
(FStar.Pervasives.pure_assume_wp @x1))
 

:pattern ((FStar.Pervasives.pure_assume_wp @x1))
:qid function_token_typing_FStar.Pervasives.pure_assume_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.pure_assume_wp@tok))
:qid function_token_typing_FStar.Pervasives.pure_assume_wp))

:named function_token_typing_FStar.Pervasives.pure_assume_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.pure_assume_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(366,4-366,18)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.pure_assume_wp @x0)
(Prims.pure_wp Prims.unit)))
 

:pattern ((FStar.Pervasives.pure_assume_wp @x0))
:qid typing_FStar.Pervasives.pure_assume_wp))

:named typing_FStar.Pervasives.pure_assume_wp))

; </end encoding FStar.Pervasives.pure_assume_wp>


; <Skipped FStar.Pervasives.DIV/>


; <Skipped />


; <Start encoding FStar.Pervasives.div_hoare_to_wp>

(declare-fun FStar.Pervasives.div_hoare_to_wp (Term Term Term) Term)
;;;;;;;;;;;;;;;;post: Prims.pure_post' a pre -> Prims.pure_wp a
(declare-fun Tm_arrow_e81e37f60b892c60a4b806bfecd6c240 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_e81e37f60b892c60a4b806bfecd6c240
Tm_type)
:named kinding_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e81e37f60b892c60a4b806bfecd6c240)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))
:qid FStar.Pervasives_pre_typing_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))

:named FStar.Pervasives_pre_typing_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e81e37f60b892c60a4b806bfecd6c240)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Prims.pure_pre)
(HasType @x3
(Prims.pure_post_ @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Prims.pure_wp @x1)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,76-397,87)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Prims.pure_pre))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))
:qid FStar.Pervasives_interpretation_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))

:named FStar.Pervasives_interpretation_Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))
(declare-fun FStar.Pervasives.div_hoare_to_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.div_hoare_to_wp@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.div_hoare_to_wp @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.div_hoare_to_wp@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.div_hoare_to_wp))

:named token_correspondence_FStar.Pervasives.div_hoare_to_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.div_hoare_to_wp@tok
Tm_arrow_e81e37f60b892c60a4b806bfecd6c240))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.div_hoare_to_wp@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.div_hoare_to_wp @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.div_hoare_to_wp @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.div_hoare_to_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.div_hoare_to_wp@tok))
:qid function_token_typing_FStar.Pervasives.div_hoare_to_wp))

:named function_token_typing_FStar.Pervasives.div_hoare_to_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Prims.pure_pre)
(HasType @x2
(Prims.pure_post_ @x0
@x1)))
(HasType (FStar.Pervasives.div_hoare_to_wp @x0
@x1
@x2)
(Prims.pure_wp @x0)))
 

:pattern ((FStar.Pervasives.div_hoare_to_wp @x0
@x1
@x2))
:qid typing_FStar.Pervasives.div_hoare_to_wp))

:named typing_FStar.Pervasives.div_hoare_to_wp))




(declare-fun Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x0
@x1
@x2
@x3)
(Tm_arrow_92458cff82f9ffee1f6e26a1c0c579f3 @x2
@x3))
 

:pattern ((Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1))

:named typing_Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x1
@x2
@x3
@x4)
@x0)
(Prims.l_imp (ApplyTT @x1
@x0)
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1))

:named interpretation_Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1))

;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (Valid (Prims.l_Forall (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x3
@x2)
(Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x1
@x0
@x2
@x3)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,32-399,58)
(forall ((@x4 Term))
 (! (implies (and (HasType @x4
(Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x3
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,43-399,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,43-399,49)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,43-399,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,43-399,49)
(ApplyTT @x1
@x4)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,54-399,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,54-399,57)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,54-399,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,54-399,57)
(ApplyTT @x0
@x4)
)
)
 
;;no pats
:qid l_quant_interp_876a1ed08b6a877c2351eb5f19aef814.1))
)
 

:pattern ((Valid (Prims.l_Forall (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x3
@x2)
(Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x1
@x0
@x2
@x3))))
:qid l_quant_interp_876a1ed08b6a877c2351eb5f19aef814))

:named l_quant_interp_876a1ed08b6a877c2351eb5f19aef814))

(declare-fun Tm_abs_95829b03554cf2093d2bc29e28500b94 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_95829b03554cf2093d2bc29e28500b94
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,25-399,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,25-399,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_95829b03554cf2093d2bc29e28500b94 @x0
@x1
@x2)
(Tm_arrow_c88a29758356586fc450d481d4b685f3 @x2))
 

:pattern ((Tm_abs_95829b03554cf2093d2bc29e28500b94 @x0
@x1
@x2))
:qid typing_Tm_abs_95829b03554cf2093d2bc29e28500b94))

:named typing_Tm_abs_95829b03554cf2093d2bc29e28500b94))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_95829b03554cf2093d2bc29e28500b94
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,25-399,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(399,25-399,58)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_95829b03554cf2093d2bc29e28500b94 @x1
@x2
@x3)
@x0)
(Prims.l_and @x1
(Prims.l_Forall (Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x3
@x1)
(Tm_abs_69982e78bbdc9cbdfcc98c8c3ec276f1 @x2
@x0
@x1
@x3))))
 

:pattern ((ApplyTT (Tm_abs_95829b03554cf2093d2bc29e28500b94 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_95829b03554cf2093d2bc29e28500b94))

:named interpretation_Tm_abs_95829b03554cf2093d2bc29e28500b94))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.div_hoare_to_wp
;;; Fact-ids: Name FStar.Pervasives.div_hoare_to_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(397,4-397,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.div_hoare_to_wp @x0
@x1
@x2)
(Tm_abs_95829b03554cf2093d2bc29e28500b94 @x1
@x2
@x0))
 

:pattern ((FStar.Pervasives.div_hoare_to_wp @x0
@x1
@x2))
:qid equation_FStar.Pervasives.div_hoare_to_wp))

:named equation_FStar.Pervasives.div_hoare_to_wp))

; </end encoding FStar.Pervasives.div_hoare_to_wp>


; <Skipped FStar.Pervasives.Div/>


; <Skipped FStar.Pervasives.Dv/>


; <Skipped FStar.Pervasives.EXT/>


; <Start encoding FStar.Pervasives.st_pre_h>

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

(declare-fun FStar.Pervasives.st_pre_h@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.st_pre_h@tok
@x0)
(FStar.Pervasives.st_pre_h @x0))
 

:pattern ((ApplyTT FStar.Pervasives.st_pre_h@tok
@x0))
:qid token_correspondence_FStar.Pervasives.st_pre_h))

:named token_correspondence_FStar.Pervasives.st_pre_h))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_pre_h@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.st_pre_h@tok
@x1)
(FStar.Pervasives.st_pre_h @x1))
 

:pattern ((FStar.Pervasives.st_pre_h @x1))
:qid function_token_typing_FStar.Pervasives.st_pre_h.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_pre_h@tok))
:qid function_token_typing_FStar.Pervasives.st_pre_h))

:named function_token_typing_FStar.Pervasives.st_pre_h))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.st_pre_h @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.st_pre_h @x0))
:qid typing_FStar.Pervasives.st_pre_h))

:named typing_FStar.Pervasives.st_pre_h))

;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_pre_h
;;; Fact-ids: Name FStar.Pervasives.st_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,4-427,12)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.st_pre_h @x0)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
 

:pattern ((FStar.Pervasives.st_pre_h @x0))
:qid equation_FStar.Pervasives.st_pre_h))

:named equation_FStar.Pervasives.st_pre_h))

; </end encoding FStar.Pervasives.st_pre_h>


; <Start encoding FStar.Pervasives.st_post_h'>

(declare-fun FStar.Pervasives.st_post_h_ (Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type -> a: Type -> pre: Type -> Type
(declare-fun Tm_arrow_659175ed40df3b798f91ffaee9e689bd () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_659175ed40df3b798f91ffaee9e689bd
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_659175ed40df3b798f91ffaee9e689bd
Tm_type)
:named kinding_Tm_arrow_659175ed40df3b798f91ffaee9e689bd))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_659175ed40df3b798f91ffaee9e689bd)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_659175ed40df3b798f91ffaee9e689bd))
:qid FStar.Pervasives_pre_typing_Tm_arrow_659175ed40df3b798f91ffaee9e689bd))

:named FStar.Pervasives_pre_typing_Tm_arrow_659175ed40df3b798f91ffaee9e689bd))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_659175ed40df3b798f91ffaee9e689bd
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_659175ed40df3b798f91ffaee9e689bd)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_659175ed40df3b798f91ffaee9e689bd.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_659175ed40df3b798f91ffaee9e689bd.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,36-432,67)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_659175ed40df3b798f91ffaee9e689bd.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_659175ed40df3b798f91ffaee9e689bd))
:qid FStar.Pervasives_interpretation_Tm_arrow_659175ed40df3b798f91ffaee9e689bd))

:named FStar.Pervasives_interpretation_Tm_arrow_659175ed40df3b798f91ffaee9e689bd))
(declare-fun FStar.Pervasives.st_post_h_@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_post_h_@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.st_post_h_ @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_post_h_@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.st_post_h_))

:named token_correspondence_FStar.Pervasives.st_post_h_))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_post_h_@tok
Tm_arrow_659175ed40df3b798f91ffaee9e689bd))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_post_h_@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.st_post_h_ @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.st_post_h_ @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.st_post_h_.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_post_h_@tok))
:qid function_token_typing_FStar.Pervasives.st_post_h_))

:named function_token_typing_FStar.Pervasives.st_post_h_))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(HasType (FStar.Pervasives.st_post_h_ @x0
@x1
@x2)
Tm_type))
 

:pattern ((FStar.Pervasives.st_post_h_ @x0
@x1
@x2))
:qid typing_FStar.Pervasives.st_post_h_))

:named typing_FStar.Pervasives.st_post_h_))

;;;;;;;;;;;;;;;;_: a -> _: heap{pre} -> Prims.GTot Type
(declare-fun Tm_arrow_14435f7112db17792f8cd33f8f7ea859 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_14435f7112db17792f8cd33f8f7ea859
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_14435f7112db17792f8cd33f8f7ea859))

:named kinding_Tm_arrow_14435f7112db17792f8cd33f8f7ea859))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x2
@x3
@x4)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_14435f7112db17792f8cd33f8f7ea859))

:named FStar.Pervasives_pre_typing_Tm_arrow_14435f7112db17792f8cd33f8f7ea859))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_14435f7112db17792f8cd33f8f7ea859
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@x3)
(HasType @x5
(Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x2
@x1)))
(HasType (ApplyTT (ApplyTT @x0
@x4)
@x5)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_14435f7112db17792f8cd33f8f7ea859.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x3)
(IsTotFun (ApplyTT @x0
@x4)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_14435f7112db17792f8cd33f8f7ea859.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x1
@x2
@x3)))
:qid FStar.Pervasives_interpretation_Tm_arrow_14435f7112db17792f8cd33f8f7ea859))

:named FStar.Pervasives_interpretation_Tm_arrow_14435f7112db17792f8cd33f8f7ea859))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_post_h'
;;; Fact-ids: Name FStar.Pervasives.st_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,4-432,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.st_post_h_ @x0
@x1
@x2)
(Tm_arrow_14435f7112db17792f8cd33f8f7ea859 @x2
@x0
@x1))
 

:pattern ((FStar.Pervasives.st_post_h_ @x0
@x1
@x2))
:qid equation_FStar.Pervasives.st_post_h_))

:named equation_FStar.Pervasives.st_post_h_))

; </end encoding FStar.Pervasives.st_post_h'>


; <Start encoding FStar.Pervasives.st_post_h>

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

(declare-fun FStar.Pervasives.st_post_h@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.st_post_h@tok
@x0)
@x1)
(FStar.Pervasives.st_post_h @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.st_post_h@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.st_post_h))

:named token_correspondence_FStar.Pervasives.st_post_h))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_post_h@tok
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.st_post_h@tok
@x1)
@x2)
(FStar.Pervasives.st_post_h @x1
@x2))
 

:pattern ((FStar.Pervasives.st_post_h @x1
@x2))
:qid function_token_typing_FStar.Pervasives.st_post_h.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_post_h@tok))
:qid function_token_typing_FStar.Pervasives.st_post_h))

:named function_token_typing_FStar.Pervasives.st_post_h))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.st_post_h @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.st_post_h @x0
@x1))
:qid typing_FStar.Pervasives.st_post_h))

:named typing_FStar.Pervasives.st_post_h))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_post_h
;;; Fact-ids: Name FStar.Pervasives.st_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(435,4-435,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.st_post_h @x0
@x1)
(FStar.Pervasives.st_post_h_ @x0
@x1
Prims.l_True))
 

:pattern ((FStar.Pervasives.st_post_h @x0
@x1))
:qid equation_FStar.Pervasives.st_post_h))

:named equation_FStar.Pervasives.st_post_h))

; </end encoding FStar.Pervasives.st_post_h>


; <Start encoding FStar.Pervasives.st_wp_h>

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

(declare-fun FStar.Pervasives.st_wp_h@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.st_wp_h@tok
@x0)
@x1)
(FStar.Pervasives.st_wp_h @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.st_wp_h@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.st_wp_h))

:named token_correspondence_FStar.Pervasives.st_wp_h))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_wp_h@tok
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.st_wp_h@tok
@x1)
@x2)
(FStar.Pervasives.st_wp_h @x1
@x2))
 

:pattern ((FStar.Pervasives.st_wp_h @x1
@x2))
:qid function_token_typing_FStar.Pervasives.st_wp_h.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_wp_h@tok))
:qid function_token_typing_FStar.Pervasives.st_wp_h))

:named function_token_typing_FStar.Pervasives.st_wp_h))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.st_wp_h @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.st_wp_h @x0
@x1))
:qid typing_FStar.Pervasives.st_wp_h))

:named typing_FStar.Pervasives.st_wp_h))
;;;;;;;;;;;;;;;;_: FStar.Pervasives.st_post_h heap a -> FStar.Pervasives.st_pre_h heap
(declare-fun Tm_arrow_c80b139653078194d2de90941effdc68 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c80b139653078194d2de90941effdc68
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_c80b139653078194d2de90941effdc68 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_c80b139653078194d2de90941effdc68 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_c80b139653078194d2de90941effdc68))

:named kinding_Tm_arrow_c80b139653078194d2de90941effdc68))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_c80b139653078194d2de90941effdc68 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_c80b139653078194d2de90941effdc68 @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_c80b139653078194d2de90941effdc68))

:named FStar.Pervasives_pre_typing_Tm_arrow_c80b139653078194d2de90941effdc68))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c80b139653078194d2de90941effdc68
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_c80b139653078194d2de90941effdc68 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,53-438,68)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(FStar.Pervasives.st_post_h @x2
@x1))
(HasType (ApplyTT @x0
@x3)
(FStar.Pervasives.st_pre_h @x2)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_c80b139653078194d2de90941effdc68.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_c80b139653078194d2de90941effdc68 @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_c80b139653078194d2de90941effdc68))

:named FStar.Pervasives_interpretation_Tm_arrow_c80b139653078194d2de90941effdc68))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_wp_h
;;; Fact-ids: Name FStar.Pervasives.st_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(438,4-438,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.st_wp_h @x0
@x1)
(Tm_arrow_c80b139653078194d2de90941effdc68 @x1
@x0))
 

:pattern ((FStar.Pervasives.st_wp_h @x0
@x1))
:qid equation_FStar.Pervasives.st_wp_h))

:named equation_FStar.Pervasives.st_wp_h))

; </end encoding FStar.Pervasives.st_wp_h>


; <Start encoding FStar.Pervasives.st_return>

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

;;;;;;;;;;;;;;;;heap: Type -> a: Type -> x: a -> p: FStar.Pervasives.st_post_h heap a -> _: heap -> Prims.GTot Type
(declare-fun Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef
Tm_type)
:named kinding_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))
:qid FStar.Pervasives_pre_typing_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))

:named FStar.Pervasives_pre_typing_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x2)
(HasType @x4
(FStar.Pervasives.st_post_h @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))
:qid FStar.Pervasives_interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))

:named FStar.Pervasives_interpretation_Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))
(declare-fun FStar.Pervasives.st_return@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_return@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.st_return @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_return@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.st_return))

:named token_correspondence_FStar.Pervasives.st_return))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_return@tok
Tm_arrow_6bfe4bf6faf1fb53a521d575cefc35ef))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_return@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.st_return @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.st_return @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.st_return.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_return@tok))
:qid function_token_typing_FStar.Pervasives.st_return))

:named function_token_typing_FStar.Pervasives.st_return))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
(FStar.Pervasives.st_post_h @x0
@x1)))
(HasType (FStar.Pervasives.st_return @x0
@x1
@x2
@x3)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)))
 

:pattern ((FStar.Pervasives.st_return @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.st_return))

:named typing_FStar.Pervasives.st_return))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_return
;;; Fact-ids: Name FStar.Pervasives.st_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(442,4-442,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.st_return @x0
@x1
@x2
@x3)
(ApplyTT @x3
@x2))
 

:pattern ((FStar.Pervasives.st_return @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.st_return))

:named equation_FStar.Pervasives.st_return))

; </end encoding FStar.Pervasives.st_return>


; <Start encoding FStar.Pervasives.st_bind_wp>

;;;;;;;;;;;;;;;;_: a -> Prims.GTot (FStar.Pervasives.st_wp_h heap b)
(declare-fun Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35))

:named kinding_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x2
@x3
@x4)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35))

:named FStar.Pervasives_pre_typing_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(450,23-450,39)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x3)
(HasType (ApplyTT @x0
@x4)
(FStar.Pervasives.st_wp_h @x2
@x1)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x1
@x2
@x3)))
:qid FStar.Pervasives_interpretation_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35))

:named FStar.Pervasives_interpretation_Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35))
(declare-fun FStar.Pervasives.st_bind_wp (Term Term Term Term Term Term Term) Term)

;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     b: Type ->     wp1: FStar.Pervasives.st_wp_h heap a ->     wp2: (_: a -> Prims.GTot (FStar.Pervasives.st_wp_h heap b)) ->     p: FStar.Pervasives.st_post_h heap b ->     h0: heap   -> Type
(declare-fun Tm_arrow_0eca50df2f29485bdbf578799f16b4a6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_0eca50df2f29485bdbf578799f16b4a6
Tm_type)
:named kinding_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_0eca50df2f29485bdbf578799f16b4a6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))
:qid FStar.Pervasives_pre_typing_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))

:named FStar.Pervasives_pre_typing_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_0eca50df2f29485bdbf578799f16b4a6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x5
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x3
@x1
@x2))
(HasType @x6
(FStar.Pervasives.st_post_h @x1
@x3))
(HasType @x7
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x5
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x3
@x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(427,41-427,46)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x5
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x3
@x1
@x2))
(HasType @x6
(FStar.Pervasives.st_post_h @x1
@x3)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))
:qid FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))

:named FStar.Pervasives_interpretation_Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))
(declare-fun FStar.Pervasives.st_bind_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.st_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.st_bind_wp))

:named token_correspondence_FStar.Pervasives.st_bind_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_bind_wp@tok
Tm_arrow_0eca50df2f29485bdbf578799f16b4a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_bind_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.st_bind_wp @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.st_bind_wp @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.st_bind_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_bind_wp@tok))
:qid function_token_typing_FStar.Pervasives.st_bind_wp))

:named function_token_typing_FStar.Pervasives.st_bind_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x0
@x1))
(HasType @x4
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x2
@x0
@x1))
(HasType @x5
(FStar.Pervasives.st_post_h @x0
@x2))
(HasType @x6
@x0))
(HasType (FStar.Pervasives.st_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Tm_type))
 

:pattern ((FStar.Pervasives.st_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.st_bind_wp))

:named typing_FStar.Pervasives.st_bind_wp))

;;;;;;;;;;;;;;;;a: a -> h1: heap -> Prims.GTot Type
(declare-fun Tm_arrow_eb9b1a038524b37579c152a3f169145e (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_eb9b1a038524b37579c152a3f169145e
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_eb9b1a038524b37579c152a3f169145e @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_eb9b1a038524b37579c152a3f169145e @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_eb9b1a038524b37579c152a3f169145e))

:named kinding_Tm_arrow_eb9b1a038524b37579c152a3f169145e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_eb9b1a038524b37579c152a3f169145e @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_eb9b1a038524b37579c152a3f169145e @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_eb9b1a038524b37579c152a3f169145e))

:named FStar.Pervasives_pre_typing_Tm_arrow_eb9b1a038524b37579c152a3f169145e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_eb9b1a038524b37579c152a3f169145e
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_eb9b1a038524b37579c152a3f169145e @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x3
@x2)
(HasType @x4
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x3)
@x4)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_eb9b1a038524b37579c152a3f169145e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(432,62-432,67)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(IsTotFun (ApplyTT @x0
@x3)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_eb9b1a038524b37579c152a3f169145e.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_eb9b1a038524b37579c152a3f169145e @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_eb9b1a038524b37579c152a3f169145e))

:named FStar.Pervasives_interpretation_Tm_arrow_eb9b1a038524b37579c152a3f169145e))
(declare-fun Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(453,24-453,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(453,24-453,34)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 @x0
@x1
@x2
@x3)
(Tm_arrow_eb9b1a038524b37579c152a3f169145e @x2
@x3))
 

:pattern ((Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558))

:named typing_Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(453,24-453,34); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(453,24-453,34)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 @x2
@x3
@x4
@x5)
@x0)
@x1)
(ApplyTT (ApplyTT (ApplyTT @x2
@x0)
@x3)
@x1))
 

:pattern ((ApplyTT (ApplyTT (Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 @x2
@x3
@x4
@x5)
@x0)
@x1))
:qid interpretation_Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558))

:named interpretation_Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_bind_wp
;;; Fact-ids: Name FStar.Pervasives.st_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(446,4-446,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.st_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(ApplyTT (ApplyTT @x3
(Tm_abs_0f3b5ee9eaa8de8cacad7d3dcacb4558 @x4
@x5
@x0
@x1))
@x6))
 

:pattern ((FStar.Pervasives.st_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid equation_FStar.Pervasives.st_bind_wp))

:named equation_FStar.Pervasives.st_bind_wp))

; </end encoding FStar.Pervasives.st_bind_wp>


; <Start encoding FStar.Pervasives.st_if_then_else>

(declare-fun FStar.Pervasives.st_if_then_else (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     p: Type ->     wp_then: FStar.Pervasives.st_wp_h heap a ->     wp_else: FStar.Pervasives.st_wp_h heap a ->     post: FStar.Pervasives.st_post_h heap a ->     h0: heap   -> Prims.logical
(declare-fun Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad
Tm_type)
:named kinding_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))
:qid FStar.Pervasives_pre_typing_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))

:named FStar.Pervasives_pre_typing_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x5
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x6
(FStar.Pervasives.st_post_h @x1
@x2))
(HasType @x7
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x5
(FStar.Pervasives.st_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,23-462,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x5
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x6
(FStar.Pervasives.st_post_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))
:qid FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))

:named FStar.Pervasives_interpretation_Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))
(declare-fun FStar.Pervasives.st_if_then_else@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.st_if_then_else))

:named token_correspondence_FStar.Pervasives.st_if_then_else))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_if_then_else@tok
Tm_arrow_6e48361e1a1c92df6ec1ff87e622ddad))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_if_then_else@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.st_if_then_else @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.st_if_then_else @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.st_if_then_else.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_if_then_else@tok))
:qid function_token_typing_FStar.Pervasives.st_if_then_else))

:named function_token_typing_FStar.Pervasives.st_if_then_else))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x0
@x1))
(HasType @x4
(FStar.Pervasives.st_wp_h @x0
@x1))
(HasType @x5
(FStar.Pervasives.st_post_h @x0
@x1))
(HasType @x6
@x0))
(HasType (FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Prims.logical))
 

:pattern ((FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.st_if_then_else))

:named typing_FStar.Pervasives.st_if_then_else))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_if_then_else
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (Valid (FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,7-462,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,7-462,50)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,7-462,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,7-462,22)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,7-462,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,7-462,22)
(ApplyTT (ApplyTT @x3
@x5)
@x6)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,26-462,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,26-462,50)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,27-462,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,27-462,29)
(not 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(458,14-458,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,28-462,29)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(458,14-458,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,28-462,29)
@x2
)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,34-462,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,34-462,49)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,34-462,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(462,34-462,49)
(ApplyTT (ApplyTT @x4
@x5)
@x6)
)
)
)
)
 

:pattern ((FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid equation_FStar.Pervasives.st_if_then_else))

:named equation_FStar.Pervasives.st_if_then_else))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_if_then_else
;;; Fact-ids: Name FStar.Pervasives.st_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(457,4-457,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(Prims.l_and (ApplyTT (ApplyTT @x3
@x5)
@x6)
(Prims.l_imp (Prims.l_not @x2)
(ApplyTT (ApplyTT @x4
@x5)
@x6))))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.st_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Prims.unit))
:qid defn_equation_FStar.Pervasives.st_if_then_else))

:named defn_equation_FStar.Pervasives.st_if_then_else))

; </end encoding FStar.Pervasives.st_if_then_else>


; <Start encoding FStar.Pervasives.st_ite_wp>

(declare-fun FStar.Pervasives.st_ite_wp (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     wp: FStar.Pervasives.st_wp_h heap a ->     post: FStar.Pervasives.st_post_h heap a ->     h0: heap   -> Prims.logical
(declare-fun Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af
Tm_type)
:named kinding_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))
:qid FStar.Pervasives_pre_typing_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))

:named FStar.Pervasives_pre_typing_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x4
(FStar.Pervasives.st_post_h @x1
@x2))
(HasType @x5
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x4
(FStar.Pervasives.st_post_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))
:qid FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))

:named FStar.Pervasives_interpretation_Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))
(declare-fun FStar.Pervasives.st_ite_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_ite_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_ite_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.st_ite_wp))

:named token_correspondence_FStar.Pervasives.st_ite_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_ite_wp@tok
Tm_arrow_eaad896c6afdcb7ade2e80b5a6a930af))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_ite_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.st_ite_wp @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.st_ite_wp @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.st_ite_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_ite_wp@tok))
:qid function_token_typing_FStar.Pervasives.st_ite_wp))

:named function_token_typing_FStar.Pervasives.st_ite_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.st_wp_h @x0
@x1))
(HasType @x3
(FStar.Pervasives.st_post_h @x0
@x1))
(HasType @x4
@x0))
(HasType (FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4)
Prims.logical))
 

:pattern ((FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.st_ite_wp))

:named typing_FStar.Pervasives.st_ite_wp))

(declare-fun Tm_abs_13c1fbac4d566537e0d0aac54993e867 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_13c1fbac4d566537e0d0aac54993e867
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x0
@x1
@x2
@x3)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x3))
 

:pattern ((Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_13c1fbac4d566537e0d0aac54993e867))

:named typing_Tm_abs_13c1fbac4d566537e0d0aac54993e867))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_13c1fbac4d566537e0d0aac54993e867
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x1
@x2
@x3
@x4)
@x0)
(Prims.l_imp (ApplyTT (ApplyTT @x1
@x2)
@x0)
(ApplyTT (ApplyTT @x3
@x2)
@x0)))
 

:pattern ((ApplyTT (Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_13c1fbac4d566537e0d0aac54993e867))

:named interpretation_Tm_abs_13c1fbac4d566537e0d0aac54993e867))

(declare-fun Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_8fca386860b07bf7135ad6a5ed4b8699
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x0
@x1
@x2
@x3)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x3))
 

:pattern ((Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_8fca386860b07bf7135ad6a5ed4b8699))

:named typing_Tm_abs_8fca386860b07bf7135ad6a5ed4b8699))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_8fca386860b07bf7135ad6a5ed4b8699
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,19-469,80)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x1
@x2
@x3
@x4)
@x0)
(Prims.l_Forall @x1
(Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x2
@x0
@x3
@x1)))
 

:pattern ((ApplyTT (Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_8fca386860b07bf7135ad6a5ed4b8699))

:named interpretation_Tm_abs_8fca386860b07bf7135ad6a5ed4b8699))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (Valid (Prims.l_Forall @x3
(Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x2
@x1
@x0
@x3)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81)
(forall ((@x4 Term) (@x5 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,80)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70)
(ApplyTT (ApplyTT @x1
@x4)
@x5)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80)
(ApplyTT (ApplyTT @x0
@x4)
@x5)
)
)

 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid l_quant_interp_4a06a3752e34c3e8863bc25a61d826f4.1))
)
 

:pattern ((Valid (Prims.l_Forall @x3
(Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x2
@x1
@x0
@x3))))
:qid l_quant_interp_4a06a3752e34c3e8863bc25a61d826f4))

:named l_quant_interp_4a06a3752e34c3e8863bc25a61d826f4))
;;;;;;;;;;;;;;;;k: FStar.Pervasives.st_post_h heap a -> Prims.GTot Type
(declare-fun Tm_arrow_8be317cd0e95382d209163cbcd734f9d (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8be317cd0e95382d209163cbcd734f9d
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_8be317cd0e95382d209163cbcd734f9d))

:named kinding_Tm_arrow_8be317cd0e95382d209163cbcd734f9d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_8be317cd0e95382d209163cbcd734f9d))

:named FStar.Pervasives_pre_typing_Tm_arrow_8be317cd0e95382d209163cbcd734f9d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8be317cd0e95382d209163cbcd734f9d
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,9-468,30)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(FStar.Pervasives.st_post_h @x2
@x1))
(HasType (ApplyTT @x0
@x3)
Tm_type))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_8be317cd0e95382d209163cbcd734f9d.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_8be317cd0e95382d209163cbcd734f9d))

:named FStar.Pervasives_interpretation_Tm_arrow_8be317cd0e95382d209163cbcd734f9d))
(declare-fun Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (HasType (Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x0
@x1
@x2
@x3
@x4)
(Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x3
@x4))
 

:pattern ((Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x0
@x1
@x2
@x3
@x4))
:qid typing_Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4))

:named typing_Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x1
@x2
@x3
@x4
@x5)
@x0)
(Prims.l_imp (Prims.l_Forall @x4
(Tm_abs_8fca386860b07bf7135ad6a5ed4b8699 @x5
@x1
@x0
@x4))
(ApplyTT (ApplyTT @x2
@x0)
@x3)))
 

:pattern ((ApplyTT (Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x1
@x2
@x3
@x4
@x5)
@x0))
:qid interpretation_Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4))

:named interpretation_Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.st_post_h @x4
@x3)
(Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x2
@x1
@x0
@x3
@x4)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
(FStar.Pervasives.st_post_h @x4
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81)
(forall ((@x6 Term) (@x7 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,80)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70)
(ApplyTT (ApplyTT @x2
@x6)
@x7)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80)
(ApplyTT (ApplyTT @x5
@x6)
@x7)
)
)

 

:pattern ((ApplyTT (ApplyTT @x5
@x6)
@x7))
:qid l_quant_interp_26d3450b26c873d8c2c9f0d83798c171.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93)
(ApplyTT (ApplyTT @x1
@x5)
@x0)
)
)
 
;;no pats
:qid l_quant_interp_26d3450b26c873d8c2c9f0d83798c171.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.st_post_h @x4
@x3)
(Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x2
@x1
@x0
@x3
@x4))))
:qid l_quant_interp_26d3450b26c873d8c2c9f0d83798c171))

:named l_quant_interp_26d3450b26c873d8c2c9f0d83798c171))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_ite_wp
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (Valid (FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(468,2-469,93)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
(FStar.Pervasives.st_post_h @x0
@x1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,4-469,81)
(forall ((@x6 Term) (@x7 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,80)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,62-469,70)
(ApplyTT (ApplyTT @x3
@x6)
@x7)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,75-469,80)
(ApplyTT (ApplyTT @x5
@x6)
@x7)
)
)

 

:pattern ((ApplyTT (ApplyTT @x5
@x6)
@x7))
:qid equation_FStar.Pervasives.st_ite_wp.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(469,86-469,93)
(ApplyTT (ApplyTT @x2
@x5)
@x4)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.st_ite_wp.1))
)
 

:pattern ((FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4))
:qid equation_FStar.Pervasives.st_ite_wp))

:named equation_FStar.Pervasives.st_ite_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_ite_wp
;;; Fact-ids: Name FStar.Pervasives.st_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(467,4-467,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4)
(Prims.l_Forall (FStar.Pervasives.st_post_h @x0
@x1)
(Tm_abs_72e7071059c05ac5aef1b1a6a8b5e8f4 @x3
@x2
@x4
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.st_ite_wp @x0
@x1
@x2
@x3
@x4)
Prims.unit))
:qid defn_equation_FStar.Pervasives.st_ite_wp))

:named defn_equation_FStar.Pervasives.st_ite_wp))

; </end encoding FStar.Pervasives.st_ite_wp>


; <Start encoding FStar.Pervasives.st_stronger>

(declare-fun FStar.Pervasives.st_stronger (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     wp1: FStar.Pervasives.st_wp_h heap a ->     wp2: FStar.Pervasives.st_wp_h heap a   -> Prims.logical
(declare-fun Tm_arrow_ae4d7f489de84317e0022bf89d45dd95 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_ae4d7f489de84317e0022bf89d45dd95
Tm_type)
:named kinding_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,10-474,31)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ae4d7f489de84317e0022bf89d45dd95)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))

:named FStar.Pervasives_pre_typing_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,10-474,31)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ae4d7f489de84317e0022bf89d45dd95)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,10-474,31)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x1
@x2))
(HasType @x4
(FStar.Pervasives.st_wp_h @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,10-474,31)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,10-474,31)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,10-474,31)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))
:qid FStar.Pervasives_interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))

:named FStar.Pervasives_interpretation_Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))
(declare-fun FStar.Pervasives.st_stronger@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_stronger@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_stronger@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.st_stronger))

:named token_correspondence_FStar.Pervasives.st_stronger))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_stronger@tok
Tm_arrow_ae4d7f489de84317e0022bf89d45dd95))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_stronger@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.st_stronger @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.st_stronger @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.st_stronger.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_stronger@tok))
:qid function_token_typing_FStar.Pervasives.st_stronger))

:named function_token_typing_FStar.Pervasives.st_stronger))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.st_wp_h @x0
@x1))
(HasType @x3
(FStar.Pervasives.st_wp_h @x0
@x1)))
(HasType (FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3)
Prims.logical))
 

:pattern ((FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.st_stronger))

:named typing_FStar.Pervasives.st_stronger))



(declare-fun Tm_abs_01fd99084e2163543709c497ff1c256b (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_01fd99084e2163543709c497ff1c256b
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,32-474,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,32-474,62)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_01fd99084e2163543709c497ff1c256b @x0
@x1
@x2
@x3)
(Tm_arrow_8be317cd0e95382d209163cbcd734f9d @x2
@x3))
 

:pattern ((Tm_abs_01fd99084e2163543709c497ff1c256b @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_01fd99084e2163543709c497ff1c256b))

:named typing_Tm_abs_01fd99084e2163543709c497ff1c256b))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_01fd99084e2163543709c497ff1c256b
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,32-474,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,32-474,62)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_01fd99084e2163543709c497ff1c256b @x1
@x2
@x3
@x4)
@x0)
(Prims.l_Forall @x4
(Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x1
@x0
@x2
@x4)))
 

:pattern ((ApplyTT (Tm_abs_01fd99084e2163543709c497ff1c256b @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_01fd99084e2163543709c497ff1c256b))

:named interpretation_Tm_abs_01fd99084e2163543709c497ff1c256b))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,2-474,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,2-474,63)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.st_post_h @x3
@x2)
(Tm_abs_01fd99084e2163543709c497ff1c256b @x1
@x0
@x2
@x3)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,2-474,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,2-474,63)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(FStar.Pervasives.st_post_h @x3
@x2))
(HasType @x5
@x3)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50)
(ApplyTT (ApplyTT @x1
@x4)
@x5)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62)
(ApplyTT (ApplyTT @x0
@x4)
@x5)
)
)
 
;;no pats
:qid l_quant_interp_b8461e2f59263d060d2ee7128b63ba8b.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.st_post_h @x3
@x2)
(Tm_abs_01fd99084e2163543709c497ff1c256b @x1
@x0
@x2
@x3))))
:qid l_quant_interp_b8461e2f59263d060d2ee7128b63ba8b))

:named l_quant_interp_b8461e2f59263d060d2ee7128b63ba8b))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_stronger
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Valid (FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,2-474,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,2-474,63)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(FStar.Pervasives.st_post_h @x0
@x1))
(HasType @x5
@x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,43-474,50)
(ApplyTT (ApplyTT @x2
@x4)
@x5)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(474,55-474,62)
(ApplyTT (ApplyTT @x3
@x4)
@x5)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.st_stronger.1))
)
 

:pattern ((FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.st_stronger))

:named equation_FStar.Pervasives.st_stronger))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_stronger
;;; Fact-ids: Name FStar.Pervasives.st_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(473,4-473,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3)
(Prims.l_Forall (FStar.Pervasives.st_post_h @x0
@x1)
(Tm_abs_01fd99084e2163543709c497ff1c256b @x2
@x3
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.st_stronger @x0
@x1
@x2
@x3)
Prims.unit))
:qid defn_equation_FStar.Pervasives.st_stronger))

:named defn_equation_FStar.Pervasives.st_stronger))

; </end encoding FStar.Pervasives.st_stronger>


; <Start encoding FStar.Pervasives.st_close_wp>


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

;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     b: Type ->     wp: (_: b -> Prims.GTot (FStar.Pervasives.st_wp_h heap a)) ->     p: FStar.Pervasives.st_post_h heap a ->     h: heap   -> Prims.logical
(declare-fun Tm_arrow_de6d3045642382698e9e38d41acfd7cc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_de6d3045642382698e9e38d41acfd7cc
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_de6d3045642382698e9e38d41acfd7cc
Tm_type)
:named kinding_Tm_arrow_de6d3045642382698e9e38d41acfd7cc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_de6d3045642382698e9e38d41acfd7cc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_de6d3045642382698e9e38d41acfd7cc))
:qid FStar.Pervasives_pre_typing_Tm_arrow_de6d3045642382698e9e38d41acfd7cc))

:named FStar.Pervasives_pre_typing_Tm_arrow_de6d3045642382698e9e38d41acfd7cc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_de6d3045642382698e9e38d41acfd7cc)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x2
@x1
@x3))
(HasType @x5
(FStar.Pervasives.st_post_h @x1
@x2))
(HasType @x6
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x2
@x1
@x3)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,10-479,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x2
@x1
@x3))
(HasType @x5
(FStar.Pervasives.st_post_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_de6d3045642382698e9e38d41acfd7cc))
:qid FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc))

:named FStar.Pervasives_interpretation_Tm_arrow_de6d3045642382698e9e38d41acfd7cc))
(declare-fun FStar.Pervasives.st_close_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_close_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_close_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.st_close_wp))

:named token_correspondence_FStar.Pervasives.st_close_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_close_wp@tok
Tm_arrow_de6d3045642382698e9e38d41acfd7cc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_close_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.st_close_wp @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.st_close_wp @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.st_close_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_close_wp@tok))
:qid function_token_typing_FStar.Pervasives.st_close_wp))

:named function_token_typing_FStar.Pervasives.st_close_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_arrow_c6e0af8c2ccbdda79db5c09d07e87e35 @x1
@x0
@x2))
(HasType @x4
(FStar.Pervasives.st_post_h @x0
@x1))
(HasType @x5
@x0))
(HasType (FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5)
Prims.logical))
 

:pattern ((FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.st_close_wp))

:named typing_FStar.Pervasives.st_close_wp))


(declare-fun Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_bd152fc5c12cc6aa125ccf543aa53813
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x0
@x1
@x2
@x3)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x3))
 

:pattern ((Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_bd152fc5c12cc6aa125ccf543aa53813))

:named typing_Tm_abs_bd152fc5c12cc6aa125ccf543aa53813))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_bd152fc5c12cc6aa125ccf543aa53813
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x1
@x2
@x3
@x4)
@x0)
(ApplyTT (ApplyTT (ApplyTT @x1
@x0)
@x2)
@x3))
 

:pattern ((ApplyTT (Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_bd152fc5c12cc6aa125ccf543aa53813))

:named interpretation_Tm_abs_bd152fc5c12cc6aa125ccf543aa53813))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (Valid (Prims.l_Forall @x3
(Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x2
@x1
@x0
@x3)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x3)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26)
(ApplyTT (ApplyTT (ApplyTT @x2
@x4)
@x1)
@x0)
)
)
 
;;no pats
:qid l_quant_interp_cc2d8ea4b793d81c1d17b922877488c9.1))
)
 

:pattern ((Valid (Prims.l_Forall @x3
(Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x2
@x1
@x0
@x3))))
:qid l_quant_interp_cc2d8ea4b793d81c1d17b922877488c9))

:named l_quant_interp_cc2d8ea4b793d81c1d17b922877488c9))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_close_wp
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Valid (FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,2-479,27)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(479,18-479,26)
(ApplyTT (ApplyTT (ApplyTT @x3
@x6)
@x4)
@x5)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.st_close_wp.1))
)
 

:pattern ((FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5))
:qid equation_FStar.Pervasives.st_close_wp))

:named equation_FStar.Pervasives.st_close_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_close_wp
;;; Fact-ids: Name FStar.Pervasives.st_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(478,4-478,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5)
(Prims.l_Forall @x2
(Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x3
@x4
@x5
@x2)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.st_close_wp @x0
@x1
@x2
@x3
@x4
@x5)
Prims.unit))
:qid defn_equation_FStar.Pervasives.st_close_wp))

:named defn_equation_FStar.Pervasives.st_close_wp))

; </end encoding FStar.Pervasives.st_close_wp>


; <Start encoding FStar.Pervasives.st_trivial>

(declare-fun FStar.Pervasives.st_trivial (Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type -> a: Type -> wp: FStar.Pervasives.st_wp_h heap a -> Prims.logical
(declare-fun Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0
Tm_type)
:named kinding_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,61-483,63)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))

:named FStar.Pervasives_pre_typing_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,61-483,63)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,61-483,63)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.st_wp_h @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,61-483,63)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,61-483,63)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))
:qid FStar.Pervasives_interpretation_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))

:named FStar.Pervasives_interpretation_Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))
(declare-fun FStar.Pervasives.st_trivial@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_trivial@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.st_trivial @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_trivial@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.st_trivial))

:named token_correspondence_FStar.Pervasives.st_trivial))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.st_trivial@tok
Tm_arrow_f145e04ff3c7033bdfc718f7f5bb1df0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.st_trivial@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.st_trivial @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.st_trivial @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.st_trivial.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.st_trivial@tok))
:qid function_token_typing_FStar.Pervasives.st_trivial))

:named function_token_typing_FStar.Pervasives.st_trivial))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.st_wp_h @x0
@x1)))
(HasType (FStar.Pervasives.st_trivial @x0
@x1
@x2)
Prims.logical))
 

:pattern ((FStar.Pervasives.st_trivial @x0
@x1
@x2))
:qid typing_FStar.Pervasives.st_trivial))

:named typing_FStar.Pervasives.st_trivial))

(declare-fun Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,81-483,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,81-483,85)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x0
@x1)
(Tm_arrow_eb9b1a038524b37579c152a3f169145e @x0
@x1))
 

:pattern ((Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x0
@x1))
:qid typing_Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2))

:named typing_Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,81-483,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,81-483,85)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x2
@x3)
@x0)
@x1)
Prims.l_True)
 

:pattern ((ApplyTT (ApplyTT (Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x2
@x3)
@x0)
@x1))
:qid interpretation_Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2))

:named interpretation_Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2))

(declare-fun Tm_abs_59c4fa07f408d911e59025309cce9942 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_59c4fa07f408d911e59025309cce9942
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_59c4fa07f408d911e59025309cce9942 @x0
@x1
@x2)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2))
 

:pattern ((Tm_abs_59c4fa07f408d911e59025309cce9942 @x0
@x1
@x2))
:qid typing_Tm_abs_59c4fa07f408d911e59025309cce9942))

:named typing_Tm_abs_59c4fa07f408d911e59025309cce9942))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_59c4fa07f408d911e59025309cce9942
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_59c4fa07f408d911e59025309cce9942 @x1
@x2
@x3)
@x0)
(ApplyTT (ApplyTT @x1
(Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x3
@x2))
@x0))
 

:pattern ((ApplyTT (Tm_abs_59c4fa07f408d911e59025309cce9942 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_59c4fa07f408d911e59025309cce9942))

:named interpretation_Tm_abs_59c4fa07f408d911e59025309cce9942))


;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall @x2
(Tm_abs_59c4fa07f408d911e59025309cce9942 @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89)
(ApplyTT (ApplyTT @x1
(Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x2
@x0))
@x3)
)
)
 
;;no pats
:qid l_quant_interp_bd29e56c5acd18065afc039fd6f7f66a.1))
)
 

:pattern ((Valid (Prims.l_Forall @x2
(Tm_abs_59c4fa07f408d911e59025309cce9942 @x1
@x0
@x2))))
:qid l_quant_interp_bd29e56c5acd18065afc039fd6f7f66a))

:named l_quant_interp_bd29e56c5acd18065afc039fd6f7f66a))


;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_trivial
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Valid (FStar.Pervasives.st_trivial @x0
@x1
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,53-483,90)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,65-483,89)
(ApplyTT (ApplyTT @x2
(Tm_abs_89b21c42be5bc00d63e29f63ae20d4e2 @x0
@x1))
@x3)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.st_trivial.1))
)
 

:pattern ((FStar.Pervasives.st_trivial @x0
@x1
@x2))
:qid equation_FStar.Pervasives.st_trivial))

:named equation_FStar.Pervasives.st_trivial))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.st_trivial
;;; Fact-ids: Name FStar.Pervasives.st_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(483,4-483,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.st_trivial @x0
@x1
@x2)
(Prims.l_Forall @x0
(Tm_abs_59c4fa07f408d911e59025309cce9942 @x2
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.st_trivial @x0
@x1
@x2)
Prims.unit))
:qid defn_equation_FStar.Pervasives.st_trivial))

:named defn_equation_FStar.Pervasives.st_trivial))

; </end encoding FStar.Pervasives.st_trivial>


; <Skipped FStar.Pervasives.STATE_h/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.result (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.result@x0 (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: 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: 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: Err
(declare-fun FStar.Pervasives.Err@tok () Term)
;;;;;;;;;;;;;;;;v: a -> FStar.Pervasives.result a
(declare-fun Tm_arrow_30908143640041985b9200e2fb38a259 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_30908143640041985b9200e2fb38a259
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_30908143640041985b9200e2fb38a259
Tm_type)
:named kinding_Tm_arrow_30908143640041985b9200e2fb38a259))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_30908143640041985b9200e2fb38a259)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_30908143640041985b9200e2fb38a259))
:qid FStar.Pervasives_pre_typing_Tm_arrow_30908143640041985b9200e2fb38a259))

:named FStar.Pervasives_pre_typing_Tm_arrow_30908143640041985b9200e2fb38a259))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_30908143640041985b9200e2fb38a259
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_30908143640041985b9200e2fb38a259)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(FStar.Pervasives.result @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_30908143640041985b9200e2fb38a259.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,16-510,24)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_30908143640041985b9200e2fb38a259.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_30908143640041985b9200e2fb38a259))
:qid FStar.Pervasives_interpretation_Tm_arrow_30908143640041985b9200e2fb38a259))

:named FStar.Pervasives_interpretation_Tm_arrow_30908143640041985b9200e2fb38a259))
;;;;;;;;;;;;;;;;e: Prims.exn -> FStar.Pervasives.result a
(declare-fun Tm_arrow_f8bb10130fea772e0f786d78a188c381 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f8bb10130fea772e0f786d78a188c381
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f8bb10130fea772e0f786d78a188c381
Tm_type)
:named kinding_Tm_arrow_f8bb10130fea772e0f786d78a188c381))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f8bb10130fea772e0f786d78a188c381)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f8bb10130fea772e0f786d78a188c381))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f8bb10130fea772e0f786d78a188c381))

:named FStar.Pervasives_pre_typing_Tm_arrow_f8bb10130fea772e0f786d78a188c381))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f8bb10130fea772e0f786d78a188c381
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f8bb10130fea772e0f786d78a188c381)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Prims.exn))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(FStar.Pervasives.result @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8bb10130fea772e0f786d78a188c381.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,18-511,26)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8bb10130fea772e0f786d78a188c381.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f8bb10130fea772e0f786d78a188c381))
:qid FStar.Pervasives_interpretation_Tm_arrow_f8bb10130fea772e0f786d78a188c381))

:named FStar.Pervasives_interpretation_Tm_arrow_f8bb10130fea772e0f786d78a188c381))
;;;;;;;;;;;;;;;;msg: Prims.string -> FStar.Pervasives.result a
(declare-fun Tm_arrow_93661c87034b0b64c4714dafbe2b02e6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_93661c87034b0b64c4714dafbe2b02e6
Tm_type)
:named kinding_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_93661c87034b0b64c4714dafbe2b02e6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))
:qid FStar.Pervasives_pre_typing_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))

:named FStar.Pervasives_pre_typing_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_93661c87034b0b64c4714dafbe2b02e6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Prims.string))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(FStar.Pervasives.result @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,25-512,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))
:qid FStar.Pervasives_interpretation_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))

:named FStar.Pervasives_interpretation_Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))

; <Start encoding FStar.Pervasives.result>


; <start constructor FStar.Pervasives.result>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11)
(forall ((@x0 Term))
 (! (= 279
(Term_constr_id (FStar.Pervasives.result @x0)))
 

:pattern ((FStar.Pervasives.result @x0))
:qid constructor_distinct_FStar.Pervasives.result))

:named constructor_distinct_FStar.Pervasives.result))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.result ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
279)
(exists ((@x0 Term))
 (! (= __@x0
(FStar.Pervasives.result @x0))
 
;;no pats
:qid is-FStar.Pervasives.result))))

; </end constructor FStar.Pervasives.result>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (= 280
(Term_constr_id FStar.Pervasives.result@tok))
:named fresh_token_FStar.Pervasives.result@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.result@tok
@x0)
(FStar.Pervasives.result @x0))
 

:pattern ((ApplyTT FStar.Pervasives.result@tok
@x0))

:pattern ((FStar.Pervasives.result @x0))
:qid token_correspondence_FStar.Pervasives.result@tok))

:named token_correspondence_FStar.Pervasives.result@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.result@tok))
:named pre_kinding_FStar.Pervasives.result@tok))
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (and (IsTotFun FStar.Pervasives.result@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.result @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.result @x0))
:qid kinding_FStar.Pervasives.result@tok))
)
:named kinding_FStar.Pervasives.result@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.result @x2))
(= (FStar.Pervasives.result @x2)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.result @x2)))
:qid FStar.Pervasives_pretyping_f012bfbe57874e314f153effb10f002f))

:named FStar.Pervasives_pretyping_f012bfbe57874e314f153effb10f002f))

; </end encoding FStar.Pervasives.result>


; <Start encoding FStar.Pervasives.V>


; <start constructor FStar.Pervasives.V>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= 286
(Term_constr_id (FStar.Pervasives.V @x0
@x1)))
 

:pattern ((FStar.Pervasives.V @x0
@x1))
:qid constructor_distinct_FStar.Pervasives.V))

:named constructor_distinct_FStar.Pervasives.V))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.V_a (FStar.Pervasives.V @x0
@x1))
@x0)
 

:pattern ((FStar.Pervasives.V @x0
@x1))
:qid projection_inverse_FStar.Pervasives.V_a))

:named projection_inverse_FStar.Pervasives.V_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.V_v (FStar.Pervasives.V @x0
@x1))
@x1)
 

:pattern ((FStar.Pervasives.V @x0
@x1))
:qid projection_inverse_FStar.Pervasives.V_v))

:named projection_inverse_FStar.Pervasives.V_v))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.V ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
286)
(= __@x0
(FStar.Pervasives.V (FStar.Pervasives.V_a __@x0)
(FStar.Pervasives.V_v __@x0)))))

; </end constructor FStar.Pervasives.V>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (= 289
(Term_constr_id FStar.Pervasives.V@tok))
:named fresh_token_FStar.Pervasives.V@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.V@tok
Tm_arrow_30908143640041985b9200e2fb38a259))
 

:pattern ((ApplyTT FStar.Pervasives.V@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.V@tok))
:qid typing_tok_FStar.Pervasives.V@tok))

:named typing_tok_FStar.Pervasives.V@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.V@tok
@x0)
@x1)
(FStar.Pervasives.V @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.V@tok
@x0)
@x1))
:qid equality_tok_FStar.Pervasives.V@tok))

:named equality_tok_FStar.Pervasives.V@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
@x1))
(HasTypeFuel @u0
(FStar.Pervasives.V @x1
@x2)
(FStar.Pervasives.result @x1)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.V @x1
@x2)
(FStar.Pervasives.result @x1)))
:qid data_typing_intro_FStar.Pervasives.V@tok))

:named data_typing_intro_FStar.Pervasives.V@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.V @x1
@x2)
(FStar.Pervasives.result @x3))
(and (HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x2
@x3)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
@x1)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.V @x1
@x2)
(FStar.Pervasives.result @x3)))
:qid data_elim_FStar.Pervasives.V))

:named data_elim_FStar.Pervasives.V))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.V @x1
@x2)
(FStar.Pervasives.result @x3))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x2
(FStar.Pervasives.V @x1
@x2))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.V @x1
@x2)
(FStar.Pervasives.result @x3)))
:qid subterm_ordering_FStar.Pervasives.V))

:named subterm_ordering_FStar.Pervasives.V))

; </end encoding FStar.Pervasives.V>


; <Start encoding FStar.Pervasives.E>


; <start constructor FStar.Pervasives.E>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= 291
(Term_constr_id (FStar.Pervasives.E @x0
@x1)))
 

:pattern ((FStar.Pervasives.E @x0
@x1))
:qid constructor_distinct_FStar.Pervasives.E))

:named constructor_distinct_FStar.Pervasives.E))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.E_a (FStar.Pervasives.E @x0
@x1))
@x0)
 

:pattern ((FStar.Pervasives.E @x0
@x1))
:qid projection_inverse_FStar.Pervasives.E_a))

:named projection_inverse_FStar.Pervasives.E_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.E_e (FStar.Pervasives.E @x0
@x1))
@x1)
 

:pattern ((FStar.Pervasives.E @x0
@x1))
:qid projection_inverse_FStar.Pervasives.E_e))

:named projection_inverse_FStar.Pervasives.E_e))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.E ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
291)
(= __@x0
(FStar.Pervasives.E (FStar.Pervasives.E_a __@x0)
(FStar.Pervasives.E_e __@x0)))))

; </end constructor FStar.Pervasives.E>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (= 294
(Term_constr_id FStar.Pervasives.E@tok))
:named fresh_token_FStar.Pervasives.E@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.E@tok
Tm_arrow_f8bb10130fea772e0f786d78a188c381))
 

:pattern ((ApplyTT FStar.Pervasives.E@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.E@tok))
:qid typing_tok_FStar.Pervasives.E@tok))

:named typing_tok_FStar.Pervasives.E@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.E@tok
@x0)
@x1)
(FStar.Pervasives.E @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.E@tok
@x0)
@x1))
:qid equality_tok_FStar.Pervasives.E@tok))

:named equality_tok_FStar.Pervasives.E@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Prims.exn))
(HasTypeFuel @u0
(FStar.Pervasives.E @x1
@x2)
(FStar.Pervasives.result @x1)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.E @x1
@x2)
(FStar.Pervasives.result @x1)))
:qid data_typing_intro_FStar.Pervasives.E@tok))

:named data_typing_intro_FStar.Pervasives.E@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.E @x1
@x2)
(FStar.Pervasives.result @x3))
(and (HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Prims.exn)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.E @x1
@x2)
(FStar.Pervasives.result @x3)))
:qid data_elim_FStar.Pervasives.E))

:named data_elim_FStar.Pervasives.E))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.E @x1
@x2)
(FStar.Pervasives.result @x3))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x2
(FStar.Pervasives.E @x1
@x2))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.E @x1
@x2)
(FStar.Pervasives.result @x3)))
:qid subterm_ordering_FStar.Pervasives.E))

:named subterm_ordering_FStar.Pervasives.E))

; </end encoding FStar.Pervasives.E>


; <Start encoding FStar.Pervasives.Err>


; <start constructor FStar.Pervasives.Err>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= 296
(Term_constr_id (FStar.Pervasives.Err @x0
@x1)))
 

:pattern ((FStar.Pervasives.Err @x0
@x1))
:qid constructor_distinct_FStar.Pervasives.Err))

:named constructor_distinct_FStar.Pervasives.Err))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Err_a (FStar.Pervasives.Err @x0
@x1))
@x0)
 

:pattern ((FStar.Pervasives.Err @x0
@x1))
:qid projection_inverse_FStar.Pervasives.Err_a))

:named projection_inverse_FStar.Pervasives.Err_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.Err_msg (FStar.Pervasives.Err @x0
@x1))
@x1)
 

:pattern ((FStar.Pervasives.Err @x0
@x1))
:qid projection_inverse_FStar.Pervasives.Err_msg))

:named projection_inverse_FStar.Pervasives.Err_msg))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Err ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
296)
(= __@x0
(FStar.Pervasives.Err (FStar.Pervasives.Err_a __@x0)
(FStar.Pervasives.Err_msg __@x0)))))

; </end constructor FStar.Pervasives.Err>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! (= 299
(Term_constr_id FStar.Pervasives.Err@tok))
:named fresh_token_FStar.Pervasives.Err@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Err@tok
Tm_arrow_93661c87034b0b64c4714dafbe2b02e6))
 

:pattern ((ApplyTT FStar.Pervasives.Err@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Err@tok))
:qid typing_tok_FStar.Pervasives.Err@tok))

:named typing_tok_FStar.Pervasives.Err@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.Err@tok
@x0)
@x1)
(FStar.Pervasives.Err @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.Err@tok
@x0)
@x1))
:qid equality_tok_FStar.Pervasives.Err@tok))

:named equality_tok_FStar.Pervasives.Err@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Prims.string))
(HasTypeFuel @u0
(FStar.Pervasives.Err @x1
@x2)
(FStar.Pervasives.result @x1)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Err @x1
@x2)
(FStar.Pervasives.result @x1)))
:qid data_typing_intro_FStar.Pervasives.Err@tok))

:named data_typing_intro_FStar.Pervasives.Err@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Err @x1
@x2)
(FStar.Pervasives.result @x3))
(and (HasTypeFuel @u0
@x3
Tm_type)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Prims.string)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Err @x1
@x2)
(FStar.Pervasives.result @x3)))
:qid data_elim_FStar.Pervasives.Err))

:named data_elim_FStar.Pervasives.Err))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Err @x1
@x2)
(FStar.Pervasives.result @x3))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x2
(FStar.Pervasives.Err @x1
@x2))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Err @x1
@x2)
(FStar.Pervasives.result @x3)))
:qid subterm_ordering_FStar.Pervasives.Err))

:named subterm_ordering_FStar.Pervasives.Err))

; </end encoding FStar.Pervasives.Err>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.result; Namespace FStar.Pervasives; Name FStar.Pervasives.V; Namespace FStar.Pervasives; Name FStar.Pervasives.E; Namespace FStar.Pervasives; Name FStar.Pervasives.Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,5-509,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(FStar.Pervasives.result @x2))
(or (and (is-FStar.Pervasives.V @x1)
(= @x2
(FStar.Pervasives.V_a @x1)))
(and (is-FStar.Pervasives.E @x1)
(= @x2
(FStar.Pervasives.E_a @x1)))
(and (is-FStar.Pervasives.Err @x1)
(= @x2
(FStar.Pervasives.Err_a @x1)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
@x1
(FStar.Pervasives.result @x2)))
:qid fuel_guarded_inversion_FStar.Pervasives.result))

:named fuel_guarded_inversion_FStar.Pervasives.result))

; </end encoding >


; <Start encoding FStar.Pervasives.uu___is_V>

(declare-fun FStar.Pervasives.uu___is_V (Term Term) Term)
;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.result a -> Prims.bool
(declare-fun Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24
Tm_type)
:named kinding_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
:qid FStar.Pervasives_pre_typing_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
:named FStar.Pervasives_pre_typing_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24)
(and (forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.result @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24.2))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
:qid FStar.Pervasives_interpretation_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
:named FStar.Pervasives_interpretation_Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))
(declare-fun FStar.Pervasives.uu___is_V@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.uu___is_V@tok
@x0)
@x1)
(FStar.Pervasives.uu___is_V @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.uu___is_V@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.uu___is_V))

:named token_correspondence_FStar.Pervasives.uu___is_V))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_V@tok
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.uu___is_V@tok
@x1)
@x2)
(FStar.Pervasives.uu___is_V @x1
@x2))
 

:pattern ((FStar.Pervasives.uu___is_V @x1
@x2))
:qid function_token_typing_FStar.Pervasives.uu___is_V.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_V@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_V))

:named function_token_typing_FStar.Pervasives.uu___is_V))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.result @x0)))
(HasType (FStar.Pervasives.uu___is_V @x0
@x1)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_V @x0
@x1))
:qid typing_FStar.Pervasives.uu___is_V))

:named typing_FStar.Pervasives.uu___is_V))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_V; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.uu___is_V @x0
@x1)
(BoxBool (is-FStar.Pervasives.V @x1)))
 

:pattern ((FStar.Pervasives.uu___is_V @x0
@x1))
:qid disc_equation_FStar.Pervasives.V))

:named disc_equation_FStar.Pervasives.V))

; </end encoding FStar.Pervasives.uu___is_V>


; <Skipped FStar.Pervasives.uu___is_V/>


; <Start encoding FStar.Pervasives.__proj__V__item__v>

(declare-fun Tm_refine_9db520b26a7f39c5a01493a3f375290d (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_9db520b26a7f39c5a01493a3f375290d @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_9db520b26a7f39c5a01493a3f375290d @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_9db520b26a7f39c5a01493a3f375290d))

:named refinement_kinding_Tm_refine_9db520b26a7f39c5a01493a3f375290d))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_9db520b26a7f39c5a01493a3f375290d @x2))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.result @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_V @x2
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_9db520b26a7f39c5a01493a3f375290d @x2)))
:qid refinement_interpretation_Tm_refine_9db520b26a7f39c5a01493a3f375290d))

:named refinement_interpretation_Tm_refine_9db520b26a7f39c5a01493a3f375290d))
;;;;;;;;;;;;;;;;haseq for Tm_refine_9db520b26a7f39c5a01493a3f375290d
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,4-510,5)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_9db520b26a7f39c5a01493a3f375290d @x0)))
(Valid (Prims.hasEq (FStar.Pervasives.result @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_9db520b26a7f39c5a01493a3f375290d @x0))))
:qid haseqTm_refine_9db520b26a7f39c5a01493a3f375290d))

:named haseqTm_refine_9db520b26a7f39c5a01493a3f375290d))
(declare-fun FStar.Pervasives.__proj__V__item__v (Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.result a {V? _} -> a
(declare-fun Tm_arrow_1ea119bf213c016916a7095486e28467 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1ea119bf213c016916a7095486e28467
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_1ea119bf213c016916a7095486e28467
Tm_type)
:named kinding_Tm_arrow_1ea119bf213c016916a7095486e28467))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1ea119bf213c016916a7095486e28467)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1ea119bf213c016916a7095486e28467))
:qid FStar.Pervasives_pre_typing_Tm_arrow_1ea119bf213c016916a7095486e28467))

:named FStar.Pervasives_pre_typing_Tm_arrow_1ea119bf213c016916a7095486e28467))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1ea119bf213c016916a7095486e28467
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1ea119bf213c016916a7095486e28467)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_9db520b26a7f39c5a01493a3f375290d @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x1))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_1ea119bf213c016916a7095486e28467.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(509,13-509,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_1ea119bf213c016916a7095486e28467.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1ea119bf213c016916a7095486e28467))
:qid FStar.Pervasives_interpretation_Tm_arrow_1ea119bf213c016916a7095486e28467))

:named FStar.Pervasives_interpretation_Tm_arrow_1ea119bf213c016916a7095486e28467))
(declare-fun FStar.Pervasives.__proj__V__item__v@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.__proj__V__item__v@tok
@x0)
@x1)
(FStar.Pervasives.__proj__V__item__v @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.__proj__V__item__v@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.__proj__V__item__v))

:named token_correspondence_FStar.Pervasives.__proj__V__item__v))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__V__item__v@tok
Tm_arrow_1ea119bf213c016916a7095486e28467))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.__proj__V__item__v@tok
@x1)
@x2)
(FStar.Pervasives.__proj__V__item__v @x1
@x2))
 

:pattern ((FStar.Pervasives.__proj__V__item__v @x1
@x2))
:qid function_token_typing_FStar.Pervasives.__proj__V__item__v.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__V__item__v@tok))
:qid function_token_typing_FStar.Pervasives.__proj__V__item__v))

:named function_token_typing_FStar.Pervasives.__proj__V__item__v))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_refine_9db520b26a7f39c5a01493a3f375290d @x0)))
(HasType (FStar.Pervasives.__proj__V__item__v @x0
@x1)
@x0))
 

:pattern ((FStar.Pervasives.__proj__V__item__v @x0
@x1))
:qid typing_FStar.Pervasives.__proj__V__item__v))

:named typing_FStar.Pervasives.__proj__V__item__v))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__V__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(510,8-510,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.__proj__V__item__v @x0
@x1)
(FStar.Pervasives.V_v @x1))
 

:pattern ((FStar.Pervasives.__proj__V__item__v @x0
@x1))
:qid proj_equation_FStar.Pervasives.V_v))

:named proj_equation_FStar.Pervasives.V_v))

; </end encoding FStar.Pervasives.__proj__V__item__v>


; <Skipped FStar.Pervasives.__proj__V__item__v/>


; <Start encoding FStar.Pervasives.uu___is_E>

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

(declare-fun FStar.Pervasives.uu___is_E@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_E; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.uu___is_E@tok
@x0)
@x1)
(FStar.Pervasives.uu___is_E @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.uu___is_E@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.uu___is_E))

:named token_correspondence_FStar.Pervasives.uu___is_E))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_E; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_E@tok
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.uu___is_E@tok
@x1)
@x2)
(FStar.Pervasives.uu___is_E @x1
@x2))
 

:pattern ((FStar.Pervasives.uu___is_E @x1
@x2))
:qid function_token_typing_FStar.Pervasives.uu___is_E.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_E@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_E))

:named function_token_typing_FStar.Pervasives.uu___is_E))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_E; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.result @x0)))
(HasType (FStar.Pervasives.uu___is_E @x0
@x1)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_E @x0
@x1))
:qid typing_FStar.Pervasives.uu___is_E))

:named typing_FStar.Pervasives.uu___is_E))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_E; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.uu___is_E @x0
@x1)
(BoxBool (is-FStar.Pervasives.E @x1)))
 

:pattern ((FStar.Pervasives.uu___is_E @x0
@x1))
:qid disc_equation_FStar.Pervasives.E))

:named disc_equation_FStar.Pervasives.E))

; </end encoding FStar.Pervasives.uu___is_E>


; <Skipped FStar.Pervasives.uu___is_E/>


; <Start encoding FStar.Pervasives.__proj__E__item__e>

(declare-fun Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_95e1e2ee29104754cc3740f5575fc6e5))

:named refinement_kinding_Tm_refine_95e1e2ee29104754cc3740f5575fc6e5))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x2))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.result @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_E @x2
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x2)))
:qid refinement_interpretation_Tm_refine_95e1e2ee29104754cc3740f5575fc6e5))

:named refinement_interpretation_Tm_refine_95e1e2ee29104754cc3740f5575fc6e5))
;;;;;;;;;;;;;;;;haseq for Tm_refine_95e1e2ee29104754cc3740f5575fc6e5
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,4-511,5)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x0)))
(Valid (Prims.hasEq (FStar.Pervasives.result @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x0))))
:qid haseqTm_refine_95e1e2ee29104754cc3740f5575fc6e5))

:named haseqTm_refine_95e1e2ee29104754cc3740f5575fc6e5))
(declare-fun FStar.Pervasives.__proj__E__item__e (Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.result a {E? _} -> Prims.exn
(declare-fun Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661
Tm_type)
:named kinding_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))
:qid FStar.Pervasives_pre_typing_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))

:named FStar.Pervasives_pre_typing_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.exn))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,11-511,14)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))
:qid FStar.Pervasives_interpretation_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))

:named FStar.Pervasives_interpretation_Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))
(declare-fun FStar.Pervasives.__proj__E__item__e@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.__proj__E__item__e@tok
@x0)
@x1)
(FStar.Pervasives.__proj__E__item__e @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.__proj__E__item__e@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.__proj__E__item__e))

:named token_correspondence_FStar.Pervasives.__proj__E__item__e))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__E__item__e@tok
Tm_arrow_19e73c373dbf3f9945c6fcfce8a07661))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.__proj__E__item__e@tok
@x1)
@x2)
(FStar.Pervasives.__proj__E__item__e @x1
@x2))
 

:pattern ((FStar.Pervasives.__proj__E__item__e @x1
@x2))
:qid function_token_typing_FStar.Pervasives.__proj__E__item__e.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__E__item__e@tok))
:qid function_token_typing_FStar.Pervasives.__proj__E__item__e))

:named function_token_typing_FStar.Pervasives.__proj__E__item__e))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_refine_95e1e2ee29104754cc3740f5575fc6e5 @x0)))
(HasType (FStar.Pervasives.__proj__E__item__e @x0
@x1)
Prims.exn))
 

:pattern ((FStar.Pervasives.__proj__E__item__e @x0
@x1))
:qid typing_FStar.Pervasives.__proj__E__item__e))

:named typing_FStar.Pervasives.__proj__E__item__e))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__E__item__e; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(511,8-511,9)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.__proj__E__item__e @x0
@x1)
(FStar.Pervasives.E_e @x1))
 

:pattern ((FStar.Pervasives.__proj__E__item__e @x0
@x1))
:qid proj_equation_FStar.Pervasives.E_e))

:named proj_equation_FStar.Pervasives.E_e))

; </end encoding FStar.Pervasives.__proj__E__item__e>


; <Skipped FStar.Pervasives.__proj__E__item__e/>


; <Start encoding FStar.Pervasives.uu___is_Err>

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

(declare-fun FStar.Pervasives.uu___is_Err@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Err@tok
@x0)
@x1)
(FStar.Pervasives.uu___is_Err @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.uu___is_Err@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.uu___is_Err))

:named token_correspondence_FStar.Pervasives.uu___is_Err))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Err@tok
Tm_arrow_5cd1d0722a6a986faf6f8e557186fe24))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Err@tok
@x1)
@x2)
(FStar.Pervasives.uu___is_Err @x1
@x2))
 

:pattern ((FStar.Pervasives.uu___is_Err @x1
@x2))
:qid function_token_typing_FStar.Pervasives.uu___is_Err.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Err@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Err))

:named function_token_typing_FStar.Pervasives.uu___is_Err))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.result @x0)))
(HasType (FStar.Pervasives.uu___is_Err @x0
@x1)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Err @x0
@x1))
:qid typing_FStar.Pervasives.uu___is_Err))

:named typing_FStar.Pervasives.uu___is_Err))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Err; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.uu___is_Err @x0
@x1)
(BoxBool (is-FStar.Pervasives.Err @x1)))
 

:pattern ((FStar.Pervasives.uu___is_Err @x0
@x1))
:qid disc_equation_FStar.Pervasives.Err))

:named disc_equation_FStar.Pervasives.Err))

; </end encoding FStar.Pervasives.uu___is_Err>


; <Skipped FStar.Pervasives.uu___is_Err/>


; <Start encoding FStar.Pervasives.__proj__Err__item__msg>

(declare-fun Tm_refine_22fb403854eba07427f92e79848f9d9f (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_22fb403854eba07427f92e79848f9d9f @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_22fb403854eba07427f92e79848f9d9f @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_22fb403854eba07427f92e79848f9d9f))

:named refinement_kinding_Tm_refine_22fb403854eba07427f92e79848f9d9f))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_22fb403854eba07427f92e79848f9d9f @x2))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.result @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_Err @x2
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_22fb403854eba07427f92e79848f9d9f @x2)))
:qid refinement_interpretation_Tm_refine_22fb403854eba07427f92e79848f9d9f))

:named refinement_interpretation_Tm_refine_22fb403854eba07427f92e79848f9d9f))
;;;;;;;;;;;;;;;;haseq for Tm_refine_22fb403854eba07427f92e79848f9d9f
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,4-512,7)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_22fb403854eba07427f92e79848f9d9f @x0)))
(Valid (Prims.hasEq (FStar.Pervasives.result @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_22fb403854eba07427f92e79848f9d9f @x0))))
:qid haseqTm_refine_22fb403854eba07427f92e79848f9d9f))

:named haseqTm_refine_22fb403854eba07427f92e79848f9d9f))
(declare-fun FStar.Pervasives.__proj__Err__item__msg (Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.result a {Err? _} -> Prims.string
(declare-fun Tm_arrow_f7e3debb858e412c9497460c5187d5cd () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f7e3debb858e412c9497460c5187d5cd
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f7e3debb858e412c9497460c5187d5cd
Tm_type)
:named kinding_Tm_arrow_f7e3debb858e412c9497460c5187d5cd))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f7e3debb858e412c9497460c5187d5cd)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f7e3debb858e412c9497460c5187d5cd))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f7e3debb858e412c9497460c5187d5cd))

:named FStar.Pervasives_pre_typing_Tm_arrow_f7e3debb858e412c9497460c5187d5cd))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f7e3debb858e412c9497460c5187d5cd
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f7e3debb858e412c9497460c5187d5cd)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_22fb403854eba07427f92e79848f9d9f @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.string))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_f7e3debb858e412c9497460c5187d5cd.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,15-512,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f7e3debb858e412c9497460c5187d5cd.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f7e3debb858e412c9497460c5187d5cd))
:qid FStar.Pervasives_interpretation_Tm_arrow_f7e3debb858e412c9497460c5187d5cd))

:named FStar.Pervasives_interpretation_Tm_arrow_f7e3debb858e412c9497460c5187d5cd))
(declare-fun FStar.Pervasives.__proj__Err__item__msg@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.__proj__Err__item__msg@tok
@x0)
@x1)
(FStar.Pervasives.__proj__Err__item__msg @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.__proj__Err__item__msg@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.__proj__Err__item__msg))

:named token_correspondence_FStar.Pervasives.__proj__Err__item__msg))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Err__item__msg@tok
Tm_arrow_f7e3debb858e412c9497460c5187d5cd))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.__proj__Err__item__msg@tok
@x1)
@x2)
(FStar.Pervasives.__proj__Err__item__msg @x1
@x2))
 

:pattern ((FStar.Pervasives.__proj__Err__item__msg @x1
@x2))
:qid function_token_typing_FStar.Pervasives.__proj__Err__item__msg.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Err__item__msg@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Err__item__msg))

:named function_token_typing_FStar.Pervasives.__proj__Err__item__msg))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_refine_22fb403854eba07427f92e79848f9d9f @x0)))
(HasType (FStar.Pervasives.__proj__Err__item__msg @x0
@x1)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__Err__item__msg @x0
@x1))
:qid typing_FStar.Pervasives.__proj__Err__item__msg))

:named typing_FStar.Pervasives.__proj__Err__item__msg))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Err__item__msg; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(512,10-512,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.__proj__Err__item__msg @x0
@x1)
(FStar.Pervasives.Err_msg @x1))
 

:pattern ((FStar.Pervasives.__proj__Err__item__msg @x0
@x1))
:qid proj_equation_FStar.Pervasives.Err_msg))

:named proj_equation_FStar.Pervasives.Err_msg))

; </end encoding FStar.Pervasives.__proj__Err__item__msg>


; <Skipped FStar.Pervasives.__proj__Err__item__msg/>


; <Start encoding FStar.Pervasives.ex_pre>

(declare-fun FStar.Pervasives.ex_pre () Term)
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_pre; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.ex_pre
Tm_type)
:named function_token_typing_FStar.Pervasives.ex_pre))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_pre; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.ex_pre
Tm_type)
:named typing_FStar.Pervasives.ex_pre))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_pre
;;; Fact-ids: Name FStar.Pervasives.ex_pre; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.ex_pre
Tm_type)
:named equation_FStar.Pervasives.ex_pre))

; </end encoding FStar.Pervasives.ex_pre>


; <Start encoding FStar.Pervasives.ex_post'>

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

(declare-fun FStar.Pervasives.ex_post_@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ex_post_@tok
@x0)
@x1)
(FStar.Pervasives.ex_post_ @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.ex_post_@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.ex_post_))

:named token_correspondence_FStar.Pervasives.ex_post_))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_post_@tok
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ex_post_@tok
@x1)
@x2)
(FStar.Pervasives.ex_post_ @x1
@x2))
 

:pattern ((FStar.Pervasives.ex_post_ @x1
@x2))
:qid function_token_typing_FStar.Pervasives.ex_post_.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_post_@tok))
:qid function_token_typing_FStar.Pervasives.ex_post_))

:named function_token_typing_FStar.Pervasives.ex_post_))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.ex_post_ @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.ex_post_ @x0
@x1))
:qid typing_FStar.Pervasives.ex_post_))

:named typing_FStar.Pervasives.ex_post_))
(declare-fun Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,29-518,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,29-518,46)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6))

:named refinement_kinding_Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,29-518,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,29-518,46)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x2
@x3))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.result @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,16-518,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,42-518,45)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,16-518,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,42-518,45)
@x3
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6))

:named refinement_interpretation_Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6))
;;;;;;;;;;;;;;;;haseq for Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,29-518,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,29-518,46)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x0
@x1)))
(Valid (Prims.hasEq (FStar.Pervasives.result @x0))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x0
@x1))))
:qid haseqTm_refine_a4dcdeeacbcb04d05a6720f786918fd6))

:named haseqTm_refine_a4dcdeeacbcb04d05a6720f786918fd6))
;;;;;;;;;;;;;;;;_: FStar.Pervasives.result a {pre} -> Prims.GTot Type
(declare-fun Tm_arrow_68b66d987e8a7bdf825af8b370553e65 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_68b66d987e8a7bdf825af8b370553e65
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_68b66d987e8a7bdf825af8b370553e65))

:named kinding_Tm_arrow_68b66d987e8a7bdf825af8b370553e65))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_68b66d987e8a7bdf825af8b370553e65))

:named FStar.Pervasives_pre_typing_Tm_arrow_68b66d987e8a7bdf825af8b370553e65))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_68b66d987e8a7bdf825af8b370553e65
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,55-518,60)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(Tm_refine_a4dcdeeacbcb04d05a6720f786918fd6 @x2
@x1))
(HasType (ApplyTT @x0
@x3)
Tm_type))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_68b66d987e8a7bdf825af8b370553e65.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_68b66d987e8a7bdf825af8b370553e65))

:named FStar.Pervasives_interpretation_Tm_arrow_68b66d987e8a7bdf825af8b370553e65))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_post'
;;; Fact-ids: Name FStar.Pervasives.ex_post'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(518,4-518,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.ex_post_ @x0
@x1)
(Tm_arrow_68b66d987e8a7bdf825af8b370553e65 @x1
@x0))
 

:pattern ((FStar.Pervasives.ex_post_ @x0
@x1))
:qid equation_FStar.Pervasives.ex_post_))

:named equation_FStar.Pervasives.ex_post_))

; </end encoding FStar.Pervasives.ex_post'>


; <Start encoding FStar.Pervasives.ex_post>

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

(declare-fun FStar.Pervasives.ex_post@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.ex_post@tok
@x0)
(FStar.Pervasives.ex_post @x0))
 

:pattern ((ApplyTT FStar.Pervasives.ex_post@tok
@x0))
:qid token_correspondence_FStar.Pervasives.ex_post))

:named token_correspondence_FStar.Pervasives.ex_post))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_post@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.ex_post@tok
@x1)
(FStar.Pervasives.ex_post @x1))
 

:pattern ((FStar.Pervasives.ex_post @x1))
:qid function_token_typing_FStar.Pervasives.ex_post.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_post@tok))
:qid function_token_typing_FStar.Pervasives.ex_post))

:named function_token_typing_FStar.Pervasives.ex_post))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.ex_post @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.ex_post @x0))
:qid typing_FStar.Pervasives.ex_post))

:named typing_FStar.Pervasives.ex_post))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_post
;;; Fact-ids: Name FStar.Pervasives.ex_post; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(521,4-521,11)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.ex_post @x0)
(FStar.Pervasives.ex_post_ @x0
Prims.l_True))
 

:pattern ((FStar.Pervasives.ex_post @x0))
:qid equation_FStar.Pervasives.ex_post))

:named equation_FStar.Pervasives.ex_post))

; </end encoding FStar.Pervasives.ex_post>


; <Start encoding FStar.Pervasives.ex_wp>

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

(declare-fun FStar.Pervasives.ex_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.ex_wp@tok
@x0)
(FStar.Pervasives.ex_wp @x0))
 

:pattern ((ApplyTT FStar.Pervasives.ex_wp@tok
@x0))
:qid token_correspondence_FStar.Pervasives.ex_wp))

:named token_correspondence_FStar.Pervasives.ex_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_wp@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.ex_wp@tok
@x1)
(FStar.Pervasives.ex_wp @x1))
 

:pattern ((FStar.Pervasives.ex_wp @x1))
:qid function_token_typing_FStar.Pervasives.ex_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_wp@tok))
:qid function_token_typing_FStar.Pervasives.ex_wp))

:named function_token_typing_FStar.Pervasives.ex_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.ex_wp @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.ex_wp @x0))
:qid typing_FStar.Pervasives.ex_wp))

:named typing_FStar.Pervasives.ex_wp))
;;;;;;;;;;;;;;;;_: FStar.Pervasives.ex_post a -> Prims.GTot FStar.Pervasives.ex_pre
(declare-fun Tm_arrow_58168e52ae0908fefec42cac825ecc69 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_58168e52ae0908fefec42cac825ecc69
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x0)
Tm_type))
:qid kinding_Tm_arrow_58168e52ae0908fefec42cac825ecc69))

:named kinding_Tm_arrow_58168e52ae0908fefec42cac825ecc69))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x2)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_58168e52ae0908fefec42cac825ecc69))

:named FStar.Pervasives_pre_typing_Tm_arrow_58168e52ae0908fefec42cac825ecc69))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_58168e52ae0908fefec42cac825ecc69
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(FStar.Pervasives.ex_post @x1))
(HasType (ApplyTT @x0
@x2)
FStar.Pervasives.ex_pre))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_58168e52ae0908fefec42cac825ecc69.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x1)))
:qid FStar.Pervasives_interpretation_Tm_arrow_58168e52ae0908fefec42cac825ecc69))

:named FStar.Pervasives_interpretation_Tm_arrow_58168e52ae0908fefec42cac825ecc69))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_wp
;;; Fact-ids: Name FStar.Pervasives.ex_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,4-524,9)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.ex_wp @x0)
(Tm_arrow_58168e52ae0908fefec42cac825ecc69 @x0))
 

:pattern ((FStar.Pervasives.ex_wp @x0))
:qid equation_FStar.Pervasives.ex_wp))

:named equation_FStar.Pervasives.ex_wp))

; </end encoding FStar.Pervasives.ex_wp>


; <Start encoding FStar.Pervasives.ex_return>

(declare-fun FStar.Pervasives.ex_return (Term Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> x: a -> p: FStar.Pervasives.ex_post a -> Prims.GTot Type
(declare-fun Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2
Tm_type)
:named kinding_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))
:qid FStar.Pervasives_pre_typing_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))

:named FStar.Pervasives_pre_typing_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
(FStar.Pervasives.ex_post @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,53-528,58)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))
:qid FStar.Pervasives_interpretation_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))

:named FStar.Pervasives_interpretation_Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))
(declare-fun FStar.Pervasives.ex_return@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_return@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.ex_return @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_return@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.ex_return))

:named token_correspondence_FStar.Pervasives.ex_return))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_return@tok
Tm_arrow_375264f6f19b4e37d33ffba9f6b1c7d2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_return@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.ex_return @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.ex_return @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.ex_return.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_return@tok))
:qid function_token_typing_FStar.Pervasives.ex_return))

:named function_token_typing_FStar.Pervasives.ex_return))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0)
(HasType @x2
(FStar.Pervasives.ex_post @x0)))
(HasType (FStar.Pervasives.ex_return @x0
@x1
@x2)
Tm_type))
 

:pattern ((FStar.Pervasives.ex_return @x0
@x1
@x2))
:qid typing_FStar.Pervasives.ex_return))

:named typing_FStar.Pervasives.ex_return))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_return
;;; Fact-ids: Name FStar.Pervasives.ex_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(528,4-528,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.ex_return @x0
@x1
@x2)
(ApplyTT @x2
(FStar.Pervasives.V @x0
@x1)))
 

:pattern ((FStar.Pervasives.ex_return @x0
@x1
@x2))
:qid equation_FStar.Pervasives.ex_return))

:named equation_FStar.Pervasives.ex_return))

; </end encoding FStar.Pervasives.ex_return>


; <Start encoding FStar.Pervasives.ex_bind_wp>

;;;;;;;;;;;;;;;;_: a -> Prims.GTot (FStar.Pervasives.ex_wp b)
(declare-fun Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad))

:named kinding_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad))

:named FStar.Pervasives_pre_typing_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,59-533,68)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(HasType (ApplyTT @x0
@x3)
(FStar.Pervasives.ex_wp @x1)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad))

:named FStar.Pervasives_interpretation_Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad))
(declare-fun FStar.Pervasives.ex_bind_wp (Term Term Term Term Term) Term)

;;;;;;;;;;;;;;;;a: Type ->     b: Type ->     wp1: FStar.Pervasives.ex_wp a ->     wp2: (_: a -> Prims.GTot (FStar.Pervasives.ex_wp b)) ->     p: FStar.Pervasives.ex_post b   -> Prims.GTot Type
(declare-fun Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885
Tm_type)
:named kinding_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))
:qid FStar.Pervasives_pre_typing_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))

:named FStar.Pervasives_pre_typing_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.ex_wp @x1))
(HasType @x4
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x2
@x1))
(HasType @x5
(FStar.Pervasives.ex_post @x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.ex_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(534,11-534,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.ex_wp @x1))
(HasType @x4
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))

:named FStar.Pervasives_interpretation_Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))
(declare-fun FStar.Pervasives.ex_bind_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.ex_bind_wp))

:named token_correspondence_FStar.Pervasives.ex_bind_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_bind_wp@tok
Tm_arrow_1da2056f1a2fe3dc8db7decf5cbd5885))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_bind_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.ex_bind_wp @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.ex_bind_wp @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.ex_bind_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_bind_wp@tok))
:qid function_token_typing_FStar.Pervasives.ex_bind_wp))

:named function_token_typing_FStar.Pervasives.ex_bind_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x0))
(HasType @x3
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x1
@x0))
(HasType @x4
(FStar.Pervasives.ex_post @x1)))
(HasType (FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4)
Tm_type))
 

:pattern ((FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.ex_bind_wp))

:named typing_FStar.Pervasives.ex_bind_wp))

;;;;;;;;;;;;;;;;rb: FStar.Pervasives.result b -> Prims.GTot Type
(declare-fun Tm_arrow_ca5db633696caf7e0cd44c11654eed8b (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,12-536,26)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x0)
Tm_type))
:qid kinding_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b))

:named kinding_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,12-536,26)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x2)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b))

:named FStar.Pervasives_pre_typing_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,12-536,26)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,12-536,26)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(FStar.Pervasives.result @x1))
(HasType (ApplyTT @x0
@x2)
Tm_type))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x1)))
:qid FStar.Pervasives_interpretation_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b))

:named FStar.Pervasives_interpretation_Tm_arrow_ca5db633696caf7e0cd44c11654eed8b))
(declare-fun Tm_abs_8074df73d1580fbbdc3470addabaf08b (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_8074df73d1580fbbdc3470addabaf08b
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_8074df73d1580fbbdc3470addabaf08b @x0
@x1
@x2)
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x2))
 

:pattern ((Tm_abs_8074df73d1580fbbdc3470addabaf08b @x0
@x1
@x2))
:qid typing_Tm_abs_8074df73d1580fbbdc3470addabaf08b))

:named typing_Tm_abs_8074df73d1580fbbdc3470addabaf08b))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_8074df73d1580fbbdc3470addabaf08b
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_8074df73d1580fbbdc3470addabaf08b @x1
@x2
@x3)
@x0)
(Prims.l_imp (ApplyTT @x1
@x0)
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_8074df73d1580fbbdc3470addabaf08b @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_8074df73d1580fbbdc3470addabaf08b))

:named interpretation_Tm_abs_8074df73d1580fbbdc3470addabaf08b))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.result @x2)
(Tm_abs_8074df73d1580fbbdc3470addabaf08b @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73)
(forall ((@x3 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,72)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63)
(ApplyTT @x1
@x3)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72)
(ApplyTT @x0
@x3)
)
)

 

:pattern ((ApplyTT @x0
@x3))
:qid l_quant_interp_59f8bfd6a5448ed81d33e9b684a70549.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.result @x2)
(Tm_abs_8074df73d1580fbbdc3470addabaf08b @x1
@x0
@x2))))
:qid l_quant_interp_59f8bfd6a5448ed81d33e9b684a70549))

:named l_quant_interp_59f8bfd6a5448ed81d33e9b684a70549))

(declare-fun Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,10-540,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,10-540,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x0
@x1
@x2
@x3)
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x3))
 

:pattern ((Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db))

:named typing_Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,10-540,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,10-540,30)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x1
@x2
@x3
@x4)
@x0)
(let ((@lb5 @x0))
(ite (is-FStar.Pervasives.V @lb5)
(ApplyTT (ApplyTT @x1
(FStar.Pervasives.V_v @lb5))
@x2)
(ite (is-FStar.Pervasives.E @lb5)
(ApplyTT @x2
(FStar.Pervasives.E @x3
(FStar.Pervasives.E_e @lb5)))
(ite (is-FStar.Pervasives.Err @lb5)
(ApplyTT @x2
(FStar.Pervasives.Err @x3
(FStar.Pervasives.Err_msg @lb5)))
Tm_unit)))))
 

:pattern ((ApplyTT (Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db))

:named interpretation_Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db))
;;;;;;;;;;;;;;;;k: FStar.Pervasives.ex_post b -> Prims.GTot Type
(declare-fun Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,9-535,23)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x0)
Tm_type))
:qid kinding_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43))

:named kinding_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,9-535,23)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x2)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43))

:named FStar.Pervasives_pre_typing_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,9-535,23)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,9-535,23)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(FStar.Pervasives.ex_post @x1))
(HasType (ApplyTT @x0
@x2)
Tm_type))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x1)))
:qid FStar.Pervasives_interpretation_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43))

:named FStar.Pervasives_interpretation_Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43))
(declare-fun Tm_abs_f22410a64e648d873bed4822ca022bb4 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_f22410a64e648d873bed4822ca022bb4
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (HasType (Tm_abs_f22410a64e648d873bed4822ca022bb4 @x0
@x1
@x2
@x3
@x4)
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x4))
 

:pattern ((Tm_abs_f22410a64e648d873bed4822ca022bb4 @x0
@x1
@x2
@x3
@x4))
:qid typing_Tm_abs_f22410a64e648d873bed4822ca022bb4))

:named typing_Tm_abs_f22410a64e648d873bed4822ca022bb4))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_f22410a64e648d873bed4822ca022bb4
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (Tm_abs_f22410a64e648d873bed4822ca022bb4 @x1
@x2
@x3
@x4
@x5)
@x0)
(Prims.l_imp (Prims.l_Forall (FStar.Pervasives.result @x5)
(Tm_abs_8074df73d1580fbbdc3470addabaf08b @x1
@x0
@x5))
(ApplyTT @x2
(Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x3
@x0
@x5
@x4))))
 

:pattern ((ApplyTT (Tm_abs_f22410a64e648d873bed4822ca022bb4 @x1
@x2
@x3
@x4
@x5)
@x0))
:qid interpretation_Tm_abs_f22410a64e648d873bed4822ca022bb4))

:named interpretation_Tm_abs_f22410a64e648d873bed4822ca022bb4))


;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.ex_post @x4)
(Tm_abs_f22410a64e648d873bed4822ca022bb4 @x3
@x2
@x1
@x0
@x4)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
(FStar.Pervasives.ex_post @x4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73)
(forall ((@x6 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,72)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63)
(ApplyTT @x3
@x6)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72)
(ApplyTT @x5
@x6)
)
)

 

:pattern ((ApplyTT @x5
@x6))
:qid l_quant_interp_b2e9541f731f35528b23810030213de9.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32)
(ApplyTT @x2
(Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x1
@x5
@x4
@x0))
)
)
 
;;no pats
:qid l_quant_interp_b2e9541f731f35528b23810030213de9.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.ex_post @x4)
(Tm_abs_f22410a64e648d873bed4822ca022bb4 @x3
@x2
@x1
@x0
@x4))))
:qid l_quant_interp_b2e9541f731f35528b23810030213de9))

:named l_quant_interp_b2e9541f731f35528b23810030213de9))


;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_bind_wp
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (Valid (FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(535,2-540,32)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
(FStar.Pervasives.ex_post @x1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,4-536,73)
(forall ((@x6 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,72)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,59-536,63)
(ApplyTT @x4
@x6)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(536,68-536,72)
(ApplyTT @x5
@x6)
)
)

 

:pattern ((ApplyTT @x5
@x6))
:qid equation_FStar.Pervasives.ex_bind_wp.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(537,4-540,32)
(ApplyTT @x2
(Tm_abs_c1d9037a5cc10cc07ba9b6a7a58728db @x3
@x5
@x1
@x0))
)
)
 
;;no pats
:qid equation_FStar.Pervasives.ex_bind_wp.1))
)
 

:pattern ((FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4))
:qid equation_FStar.Pervasives.ex_bind_wp))

:named equation_FStar.Pervasives.ex_bind_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_bind_wp
;;; Fact-ids: Name FStar.Pervasives.ex_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(533,4-533,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4)
(Prims.l_Forall (FStar.Pervasives.ex_post @x1)
(Tm_abs_f22410a64e648d873bed4822ca022bb4 @x4
@x2
@x3
@x0
@x1)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.ex_bind_wp @x0
@x1
@x2
@x3
@x4)
Prims.unit))
:qid defn_equation_FStar.Pervasives.ex_bind_wp))

:named defn_equation_FStar.Pervasives.ex_bind_wp))

; </end encoding FStar.Pervasives.ex_bind_wp>


; <Start encoding FStar.Pervasives.ex_if_then_else>

(declare-fun FStar.Pervasives.ex_if_then_else (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;a: Type ->     p: Type ->     wp_then: FStar.Pervasives.ex_wp a ->     wp_else: FStar.Pervasives.ex_wp a ->     post: FStar.Pervasives.ex_post a   -> Prims.logical
(declare-fun Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0
Tm_type)
:named kinding_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))
:qid FStar.Pervasives_pre_typing_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))

:named FStar.Pervasives_pre_typing_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.ex_wp @x1))
(HasType @x4
(FStar.Pervasives.ex_wp @x1))
(HasType @x5
(FStar.Pervasives.ex_post @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.ex_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,15-546,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.ex_wp @x1))
(HasType @x4
(FStar.Pervasives.ex_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))
:qid FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))

:named FStar.Pervasives_interpretation_Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))
(declare-fun FStar.Pervasives.ex_if_then_else@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.ex_if_then_else))

:named token_correspondence_FStar.Pervasives.ex_if_then_else))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_if_then_else@tok
Tm_arrow_08bd7ce530cc6e8b4a3f8dadbd0806b0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_if_then_else@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.ex_if_then_else @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.ex_if_then_else @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.ex_if_then_else.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_if_then_else@tok))
:qid function_token_typing_FStar.Pervasives.ex_if_then_else))

:named function_token_typing_FStar.Pervasives.ex_if_then_else))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x0))
(HasType @x3
(FStar.Pervasives.ex_wp @x0))
(HasType @x4
(FStar.Pervasives.ex_post @x0)))
(HasType (FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4)
Prims.logical))
 

:pattern ((FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.ex_if_then_else))

:named typing_FStar.Pervasives.ex_if_then_else))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_if_then_else
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (Valid (FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,2-546,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,2-546,39)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,2-546,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,2-546,14)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,2-546,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,2-546,14)
(ApplyTT @x2
@x4)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,18-546,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,18-546,39)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,19-546,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,19-546,21)
(not 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,23-545,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,20-546,21)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,23-545,24); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,20-546,21)
@x1
)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,26-546,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,26-546,38)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,26-546,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(546,26-546,38)
(ApplyTT @x3
@x4)
)
)
)
)
 

:pattern ((FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4))
:qid equation_FStar.Pervasives.ex_if_then_else))

:named equation_FStar.Pervasives.ex_if_then_else))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_if_then_else
;;; Fact-ids: Name FStar.Pervasives.ex_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(545,4-545,19)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4)
(Prims.l_and (ApplyTT @x2
@x4)
(Prims.l_imp (Prims.l_not @x1)
(ApplyTT @x3
@x4))))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.ex_if_then_else @x0
@x1
@x2
@x3
@x4)
Prims.unit))
:qid defn_equation_FStar.Pervasives.ex_if_then_else))

:named defn_equation_FStar.Pervasives.ex_if_then_else))

; </end encoding FStar.Pervasives.ex_if_then_else>


; <Start encoding FStar.Pervasives.ex_ite_wp>

(declare-fun FStar.Pervasives.ex_ite_wp (Term Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> wp: FStar.Pervasives.ex_wp a -> post: FStar.Pervasives.ex_post a -> Prims.logical
(declare-fun Tm_arrow_c2a8c761b16a75376b24262cd8c50369 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c2a8c761b16a75376b24262cd8c50369
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_c2a8c761b16a75376b24262cd8c50369
Tm_type)
:named kinding_Tm_arrow_c2a8c761b16a75376b24262cd8c50369))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,9-551,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c2a8c761b16a75376b24262cd8c50369)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c2a8c761b16a75376b24262cd8c50369))
:qid FStar.Pervasives_pre_typing_Tm_arrow_c2a8c761b16a75376b24262cd8c50369))

:named FStar.Pervasives_pre_typing_Tm_arrow_c2a8c761b16a75376b24262cd8c50369))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c2a8c761b16a75376b24262cd8c50369
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,9-551,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c2a8c761b16a75376b24262cd8c50369)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,9-551,23)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x1))
(HasType @x3
(FStar.Pervasives.ex_post @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_c2a8c761b16a75376b24262cd8c50369.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,9-551,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_c2a8c761b16a75376b24262cd8c50369.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,9-551,23)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_c2a8c761b16a75376b24262cd8c50369.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c2a8c761b16a75376b24262cd8c50369))
:qid FStar.Pervasives_interpretation_Tm_arrow_c2a8c761b16a75376b24262cd8c50369))

:named FStar.Pervasives_interpretation_Tm_arrow_c2a8c761b16a75376b24262cd8c50369))
(declare-fun FStar.Pervasives.ex_ite_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_ite_wp@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.ex_ite_wp @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_ite_wp@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.ex_ite_wp))

:named token_correspondence_FStar.Pervasives.ex_ite_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_ite_wp@tok
Tm_arrow_c2a8c761b16a75376b24262cd8c50369))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_ite_wp@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.ex_ite_wp @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.ex_ite_wp @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.ex_ite_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_ite_wp@tok))
:qid function_token_typing_FStar.Pervasives.ex_ite_wp))

:named function_token_typing_FStar.Pervasives.ex_ite_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.ex_wp @x0))
(HasType @x2
(FStar.Pervasives.ex_post @x0)))
(HasType (FStar.Pervasives.ex_ite_wp @x0
@x1
@x2)
Prims.logical))
 

:pattern ((FStar.Pervasives.ex_ite_wp @x0
@x1
@x2))
:qid typing_FStar.Pervasives.ex_ite_wp))

:named typing_FStar.Pervasives.ex_ite_wp))




(declare-fun Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x0
@x1
@x2)
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x2))
 

:pattern ((Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x0
@x1
@x2))
:qid typing_Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00))

:named typing_Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x1
@x2
@x3)
@x0)
(Prims.l_imp (Prims.l_Forall (FStar.Pervasives.result @x3)
(Tm_abs_8074df73d1580fbbdc3470addabaf08b @x1
@x0
@x3))
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00))

:named interpretation_Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.ex_post @x2)
(Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
(FStar.Pervasives.ex_post @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,4-552,76); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,4-552,76)
(forall ((@x4 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,75)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66)
(ApplyTT @x1
@x4)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75)
(ApplyTT @x3
@x4)
)
)

 

:pattern ((ApplyTT @x3
@x4))
:qid l_quant_interp_18d45a514f38bf12f302d0ac4340d50e.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85)
(ApplyTT @x0
@x3)
)
)
 
;;no pats
:qid l_quant_interp_18d45a514f38bf12f302d0ac4340d50e.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.ex_post @x2)
(Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x1
@x0
@x2))))
:qid l_quant_interp_18d45a514f38bf12f302d0ac4340d50e))

:named l_quant_interp_18d45a514f38bf12f302d0ac4340d50e))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_ite_wp
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Valid (FStar.Pervasives.ex_ite_wp @x0
@x1
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(551,2-552,85)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
(FStar.Pervasives.ex_post @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,4-552,76); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,4-552,76)
(forall ((@x4 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,75)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,59-552,66)
(ApplyTT @x2
@x4)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,71-552,75)
(ApplyTT @x3
@x4)
)
)

 

:pattern ((ApplyTT @x3
@x4))
:qid equation_FStar.Pervasives.ex_ite_wp.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(552,81-552,85)
(ApplyTT @x1
@x3)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.ex_ite_wp.1))
)
 

:pattern ((FStar.Pervasives.ex_ite_wp @x0
@x1
@x2))
:qid equation_FStar.Pervasives.ex_ite_wp))

:named equation_FStar.Pervasives.ex_ite_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_ite_wp
;;; Fact-ids: Name FStar.Pervasives.ex_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(550,4-550,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.ex_ite_wp @x0
@x1
@x2)
(Prims.l_Forall (FStar.Pervasives.ex_post @x0)
(Tm_abs_a7cc1da09b297d88bb79b1fa0b467b00 @x2
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.ex_ite_wp @x0
@x1
@x2)
Prims.unit))
:qid defn_equation_FStar.Pervasives.ex_ite_wp))

:named defn_equation_FStar.Pervasives.ex_ite_wp))

; </end encoding FStar.Pervasives.ex_ite_wp>


; <Start encoding FStar.Pervasives.ex_stronger>

(declare-fun FStar.Pervasives.ex_stronger (Term Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> wp1: FStar.Pervasives.ex_wp a -> wp2: FStar.Pervasives.ex_wp a -> Prims.logical
(declare-fun Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af
Tm_type)
:named kinding_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,55-556,69)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))
:qid FStar.Pervasives_pre_typing_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))

:named FStar.Pervasives_pre_typing_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,55-556,69)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,55-556,69)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x1))
(HasType @x3
(FStar.Pervasives.ex_wp @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,55-556,69)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,55-556,69)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))
:qid FStar.Pervasives_interpretation_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))

:named FStar.Pervasives_interpretation_Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))
(declare-fun FStar.Pervasives.ex_stronger@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_stronger@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.ex_stronger @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_stronger@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.ex_stronger))

:named token_correspondence_FStar.Pervasives.ex_stronger))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_stronger@tok
Tm_arrow_1376d97b5d43e7d77d56729e2a3e04af))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_stronger@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.ex_stronger @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.ex_stronger @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.ex_stronger.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_stronger@tok))
:qid function_token_typing_FStar.Pervasives.ex_stronger))

:named function_token_typing_FStar.Pervasives.ex_stronger))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.ex_wp @x0))
(HasType @x2
(FStar.Pervasives.ex_wp @x0)))
(HasType (FStar.Pervasives.ex_stronger @x0
@x1
@x2)
Prims.logical))
 

:pattern ((FStar.Pervasives.ex_stronger @x0
@x1
@x2))
:qid typing_FStar.Pervasives.ex_stronger))

:named typing_FStar.Pervasives.ex_stronger))

(declare-fun Tm_abs_1518a3cc57d7490d55df77581752827a (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_1518a3cc57d7490d55df77581752827a
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_1518a3cc57d7490d55df77581752827a @x0
@x1
@x2)
(Tm_arrow_9ea71f7f2fb13f04805b20355b90ad43 @x2))
 

:pattern ((Tm_abs_1518a3cc57d7490d55df77581752827a @x0
@x1
@x2))
:qid typing_Tm_abs_1518a3cc57d7490d55df77581752827a))

:named typing_Tm_abs_1518a3cc57d7490d55df77581752827a))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_1518a3cc57d7490d55df77581752827a
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_1518a3cc57d7490d55df77581752827a @x1
@x2
@x3)
@x0)
(Prims.l_imp (ApplyTT @x1
@x0)
(ApplyTT @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_1518a3cc57d7490d55df77581752827a @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_1518a3cc57d7490d55df77581752827a))

:named interpretation_Tm_abs_1518a3cc57d7490d55df77581752827a))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.ex_post @x2)
(Tm_abs_1518a3cc57d7490d55df77581752827a @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
(FStar.Pervasives.ex_post @x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76)
(ApplyTT @x1
@x3)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86)
(ApplyTT @x0
@x3)
)
)
 
;;no pats
:qid l_quant_interp_c70c4b7f709d4ec4e9865b6154fc47e3.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.ex_post @x2)
(Tm_abs_1518a3cc57d7490d55df77581752827a @x1
@x0
@x2))))
:qid l_quant_interp_c70c4b7f709d4ec4e9865b6154fc47e3))

:named l_quant_interp_c70c4b7f709d4ec4e9865b6154fc47e3))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_stronger
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Valid (FStar.Pervasives.ex_stronger @x0
@x1
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,47-556,87)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
(FStar.Pervasives.ex_post @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,71-556,76)
(ApplyTT @x1
@x3)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,81-556,86)
(ApplyTT @x2
@x3)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.ex_stronger.1))
)
 

:pattern ((FStar.Pervasives.ex_stronger @x0
@x1
@x2))
:qid equation_FStar.Pervasives.ex_stronger))

:named equation_FStar.Pervasives.ex_stronger))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_stronger
;;; Fact-ids: Name FStar.Pervasives.ex_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(556,4-556,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.ex_stronger @x0
@x1
@x2)
(Prims.l_Forall (FStar.Pervasives.ex_post @x0)
(Tm_abs_1518a3cc57d7490d55df77581752827a @x1
@x2
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.ex_stronger @x0
@x1
@x2)
Prims.unit))
:qid defn_equation_FStar.Pervasives.ex_stronger))

:named defn_equation_FStar.Pervasives.ex_stronger))

; </end encoding FStar.Pervasives.ex_stronger>


; <Start encoding FStar.Pervasives.ex_close_wp>


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

;;;;;;;;;;;;;;;;a: Type ->     b: Type ->     wp: (_: b -> Prims.GTot (FStar.Pervasives.ex_wp a)) ->     p: FStar.Pervasives.ex_post a   -> Prims.logical
(declare-fun Tm_arrow_814af0adff92aa08c5b8b0951bcb1959 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_814af0adff92aa08c5b8b0951bcb1959
Tm_type)
:named kinding_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,81-560,87)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_814af0adff92aa08c5b8b0951bcb1959)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))
:qid FStar.Pervasives_pre_typing_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))

:named FStar.Pervasives_pre_typing_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,81-560,87)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_814af0adff92aa08c5b8b0951bcb1959)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,81-560,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x1
@x2))
(HasType @x4
(FStar.Pervasives.ex_post @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,81-560,87)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,81-560,87)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,81-560,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))
:qid FStar.Pervasives_interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))

:named FStar.Pervasives_interpretation_Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))
(declare-fun FStar.Pervasives.ex_close_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_close_wp@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_close_wp@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.ex_close_wp))

:named token_correspondence_FStar.Pervasives.ex_close_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_close_wp@tok
Tm_arrow_814af0adff92aa08c5b8b0951bcb1959))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.ex_close_wp@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.ex_close_wp @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.ex_close_wp @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.ex_close_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_close_wp@tok))
:qid function_token_typing_FStar.Pervasives.ex_close_wp))

:named function_token_typing_FStar.Pervasives.ex_close_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_3eb2992a529511f5b0ff2fef4e4594ad @x0
@x1))
(HasType @x3
(FStar.Pervasives.ex_post @x0)))
(HasType (FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3)
Prims.logical))
 

:pattern ((FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.ex_close_wp))

:named typing_FStar.Pervasives.ex_close_wp))




;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_close_wp
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Valid (FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,73-560,96); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,73-560,96)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x1)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,89-560,95); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,89-560,95)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,89-560,95); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,89-560,95)
(ApplyTT (ApplyTT @x2
@x4)
@x3)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.ex_close_wp.1))
)
 

:pattern ((FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.ex_close_wp))

:named equation_FStar.Pervasives.ex_close_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_close_wp
;;; Fact-ids: Name FStar.Pervasives.ex_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(560,4-560,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3)
(Prims.l_Forall @x1
(Tm_abs_d0f415a5361a9d7988d8e425dc193472 @x2
@x3
@x1)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.ex_close_wp @x0
@x1
@x2
@x3)
Prims.unit))
:qid defn_equation_FStar.Pervasives.ex_close_wp))

:named defn_equation_FStar.Pervasives.ex_close_wp))

; </end encoding FStar.Pervasives.ex_close_wp>


; <Start encoding FStar.Pervasives.ex_trivial>

(declare-fun FStar.Pervasives.ex_trivial (Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> wp: FStar.Pervasives.ex_wp a -> FStar.Pervasives.ex_pre
(declare-fun Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c
Tm_type)
:named kinding_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))

:named FStar.Pervasives_pre_typing_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.ex_wp @x1)))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
FStar.Pervasives.ex_pre))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(524,40-524,46)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))

:named FStar.Pervasives_interpretation_Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))
(declare-fun FStar.Pervasives.ex_trivial@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ex_trivial@tok
@x0)
@x1)
(FStar.Pervasives.ex_trivial @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.ex_trivial@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.ex_trivial))

:named token_correspondence_FStar.Pervasives.ex_trivial))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ex_trivial@tok
Tm_arrow_ee4a787765920b0cb4357a47a0d3ac5c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ex_trivial@tok
@x1)
@x2)
(FStar.Pervasives.ex_trivial @x1
@x2))
 

:pattern ((FStar.Pervasives.ex_trivial @x1
@x2))
:qid function_token_typing_FStar.Pervasives.ex_trivial.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ex_trivial@tok))
:qid function_token_typing_FStar.Pervasives.ex_trivial))

:named function_token_typing_FStar.Pervasives.ex_trivial))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(FStar.Pervasives.ex_wp @x0)))
(HasType (FStar.Pervasives.ex_trivial @x0
@x1)
FStar.Pervasives.ex_pre))
 

:pattern ((FStar.Pervasives.ex_trivial @x0
@x1))
:qid typing_FStar.Pervasives.ex_trivial))

:named typing_FStar.Pervasives.ex_trivial))

(declare-fun Tm_abs_5cc223716d095f4545f0dcc745acad5d (Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_5cc223716d095f4545f0dcc745acad5d
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,54-564,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,54-564,58)
(forall ((@x0 Term))
 (! (HasType (Tm_abs_5cc223716d095f4545f0dcc745acad5d @x0)
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x0))
 

:pattern ((Tm_abs_5cc223716d095f4545f0dcc745acad5d @x0))
:qid typing_Tm_abs_5cc223716d095f4545f0dcc745acad5d))

:named typing_Tm_abs_5cc223716d095f4545f0dcc745acad5d))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_5cc223716d095f4545f0dcc745acad5d
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,54-564,58); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,54-564,58)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (Tm_abs_5cc223716d095f4545f0dcc745acad5d @x1)
@x0)
Prims.l_True)
 

:pattern ((ApplyTT (Tm_abs_5cc223716d095f4545f0dcc745acad5d @x1)
@x0))
:qid interpretation_Tm_abs_5cc223716d095f4545f0dcc745acad5d))

:named interpretation_Tm_abs_5cc223716d095f4545f0dcc745acad5d))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ex_trivial
;;; Fact-ids: Name FStar.Pervasives.ex_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(564,4-564,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.ex_trivial @x0
@x1)
(ApplyTT @x1
(Tm_abs_5cc223716d095f4545f0dcc745acad5d @x0)))
 

:pattern ((FStar.Pervasives.ex_trivial @x0
@x1))
:qid equation_FStar.Pervasives.ex_trivial))

:named equation_FStar.Pervasives.ex_trivial))

; </end encoding FStar.Pervasives.ex_trivial>


; <Skipped FStar.Pervasives.EXN/>


; <Skipped FStar.Pervasives.Exn/>


; <Start encoding FStar.Pervasives.lift_div_exn>

(declare-fun FStar.Pervasives.lift_div_exn (Term Term Term) Term)
;;;;;;;;;;;;;;;;a: Type -> wp: Prims.pure_wp a -> p: FStar.Pervasives.ex_post a -> Prims.pure_pre
(declare-fun Tm_arrow_8196682216f286f6fe3a7dffb3de7d02 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_8196682216f286f6fe3a7dffb3de7d02
Tm_type)
:named kinding_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8196682216f286f6fe3a7dffb3de7d02)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))
:qid FStar.Pervasives_pre_typing_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))

:named FStar.Pervasives_pre_typing_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8196682216f286f6fe3a7dffb3de7d02)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Prims.pure_wp @x1))
(HasType @x3
(FStar.Pervasives.ex_post @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.pure_pre))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(312,45-312,53)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Prims.pure_wp @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))
:qid FStar.Pervasives_interpretation_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))

:named FStar.Pervasives_interpretation_Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))
(declare-fun FStar.Pervasives.lift_div_exn@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.lift_div_exn@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.lift_div_exn @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.lift_div_exn@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.lift_div_exn))

:named token_correspondence_FStar.Pervasives.lift_div_exn))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.lift_div_exn@tok
Tm_arrow_8196682216f286f6fe3a7dffb3de7d02))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.lift_div_exn@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.lift_div_exn @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.lift_div_exn @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.lift_div_exn.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.lift_div_exn@tok))
:qid function_token_typing_FStar.Pervasives.lift_div_exn))

:named function_token_typing_FStar.Pervasives.lift_div_exn))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Prims.pure_wp @x0))
(HasType @x2
(FStar.Pervasives.ex_post @x0)))
(HasType (FStar.Pervasives.lift_div_exn @x0
@x1
@x2)
Prims.pure_pre))
 

:pattern ((FStar.Pervasives.lift_div_exn @x0
@x1
@x2))
:qid typing_FStar.Pervasives.lift_div_exn))

:named typing_FStar.Pervasives.lift_div_exn))

(declare-fun Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,73-588,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,73-588,80)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 @x0
@x1)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
 

:pattern ((Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 @x0
@x1))
:qid typing_Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5))

:named typing_Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,73-588,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,73-588,80)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 @x1
@x2)
@x0)
(ApplyTT @x1
(FStar.Pervasives.V @x2
@x0)))
 

:pattern ((ApplyTT (Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 @x1
@x2)
@x0))
:qid interpretation_Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5))

:named interpretation_Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.lift_div_exn
;;; Fact-ids: Name FStar.Pervasives.lift_div_exn; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(588,4-588,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.lift_div_exn @x0
@x1
@x2)
(ApplyTT @x1
(Tm_abs_c2b605ddd5d1991642baf5762d2b1dc5 @x2
@x0)))
 

:pattern ((FStar.Pervasives.lift_div_exn @x0
@x1
@x2))
:qid equation_FStar.Pervasives.lift_div_exn))

:named equation_FStar.Pervasives.lift_div_exn))

; </end encoding FStar.Pervasives.lift_div_exn>


; <Skipped />


; <Skipped FStar.Pervasives.Ex/>


; <Start encoding FStar.Pervasives.all_pre_h>

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

(declare-fun FStar.Pervasives.all_pre_h@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.all_pre_h@tok
@x0)
(FStar.Pervasives.all_pre_h @x0))
 

:pattern ((ApplyTT FStar.Pervasives.all_pre_h@tok
@x0))
:qid token_correspondence_FStar.Pervasives.all_pre_h))

:named token_correspondence_FStar.Pervasives.all_pre_h))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_pre_h@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.all_pre_h@tok
@x1)
(FStar.Pervasives.all_pre_h @x1))
 

:pattern ((FStar.Pervasives.all_pre_h @x1))
:qid function_token_typing_FStar.Pervasives.all_pre_h.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_pre_h@tok))
:qid function_token_typing_FStar.Pervasives.all_pre_h))

:named function_token_typing_FStar.Pervasives.all_pre_h))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.all_pre_h @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.all_pre_h @x0))
:qid typing_FStar.Pervasives.all_pre_h))

:named typing_FStar.Pervasives.all_pre_h))

;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_pre_h
;;; Fact-ids: Name FStar.Pervasives.all_pre_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(610,4-610,13)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.all_pre_h @x0)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
 

:pattern ((FStar.Pervasives.all_pre_h @x0))
:qid equation_FStar.Pervasives.all_pre_h))

:named equation_FStar.Pervasives.all_pre_h))

; </end encoding FStar.Pervasives.all_pre_h>


; <Start encoding FStar.Pervasives.all_post_h'>

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

(declare-fun FStar.Pervasives.all_post_h_@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_post_h_@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.all_post_h_ @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_post_h_@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.all_post_h_))

:named token_correspondence_FStar.Pervasives.all_post_h_))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_post_h_@tok
Tm_arrow_659175ed40df3b798f91ffaee9e689bd))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_post_h_@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.all_post_h_ @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.all_post_h_ @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.all_post_h_.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_post_h_@tok))
:qid function_token_typing_FStar.Pervasives.all_post_h_))

:named function_token_typing_FStar.Pervasives.all_post_h_))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(HasType (FStar.Pervasives.all_post_h_ @x0
@x1
@x2)
Tm_type))
 

:pattern ((FStar.Pervasives.all_post_h_ @x0
@x1
@x2))
:qid typing_FStar.Pervasives.all_post_h_))

:named typing_FStar.Pervasives.all_post_h_))

;;;;;;;;;;;;;;;;_: FStar.Pervasives.result a -> _: h{pre} -> Prims.GTot Type
(declare-fun Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269))

:named kinding_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x2
@x3
@x4)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269))

:named FStar.Pervasives_pre_typing_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(FStar.Pervasives.result @x3))
(HasType @x5
(Tm_refine_8d65e998a07dd53ec478e27017d9dba5 @x2
@x1)))
(HasType (ApplyTT (ApplyTT @x0
@x4)
@x5)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x4 Term))
 (! (implies (HasType @x4
(FStar.Pervasives.result @x3))
(IsTotFun (ApplyTT @x0
@x4)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x1
@x2
@x3)))
:qid FStar.Pervasives_interpretation_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269))

:named FStar.Pervasives_interpretation_Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_post_h'
;;; Fact-ids: Name FStar.Pervasives.all_post_h'; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,4-613,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.all_post_h_ @x0
@x1
@x2)
(Tm_arrow_fc269489cb2e24a10c7710a1f7f9d269 @x2
@x0
@x1))
 

:pattern ((FStar.Pervasives.all_post_h_ @x0
@x1
@x2))
:qid equation_FStar.Pervasives.all_post_h_))

:named equation_FStar.Pervasives.all_post_h_))

; </end encoding FStar.Pervasives.all_post_h'>


; <Start encoding FStar.Pervasives.all_post_h>

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

(declare-fun FStar.Pervasives.all_post_h@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.all_post_h@tok
@x0)
@x1)
(FStar.Pervasives.all_post_h @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.all_post_h@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.all_post_h))

:named token_correspondence_FStar.Pervasives.all_post_h))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_post_h@tok
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.all_post_h@tok
@x1)
@x2)
(FStar.Pervasives.all_post_h @x1
@x2))
 

:pattern ((FStar.Pervasives.all_post_h @x1
@x2))
:qid function_token_typing_FStar.Pervasives.all_post_h.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_post_h@tok))
:qid function_token_typing_FStar.Pervasives.all_post_h))

:named function_token_typing_FStar.Pervasives.all_post_h))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.all_post_h @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.all_post_h @x0
@x1))
:qid typing_FStar.Pervasives.all_post_h))

:named typing_FStar.Pervasives.all_post_h))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_post_h
;;; Fact-ids: Name FStar.Pervasives.all_post_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(616,4-616,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.all_post_h @x0
@x1)
(FStar.Pervasives.all_post_h_ @x0
@x1
Prims.l_True))
 

:pattern ((FStar.Pervasives.all_post_h @x0
@x1))
:qid equation_FStar.Pervasives.all_post_h))

:named equation_FStar.Pervasives.all_post_h))

; </end encoding FStar.Pervasives.all_post_h>


; <Start encoding FStar.Pervasives.all_wp_h>

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

(declare-fun FStar.Pervasives.all_wp_h@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.all_wp_h@tok
@x0)
@x1)
(FStar.Pervasives.all_wp_h @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.all_wp_h@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.all_wp_h))

:named token_correspondence_FStar.Pervasives.all_wp_h))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_wp_h@tok
Tm_arrow_e4cf09589736facd1137944a1f5a00a6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.all_wp_h@tok
@x1)
@x2)
(FStar.Pervasives.all_wp_h @x1
@x2))
 

:pattern ((FStar.Pervasives.all_wp_h @x1
@x2))
:qid function_token_typing_FStar.Pervasives.all_wp_h.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_wp_h@tok))
:qid function_token_typing_FStar.Pervasives.all_wp_h))

:named function_token_typing_FStar.Pervasives.all_wp_h))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.all_wp_h @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.all_wp_h @x0
@x1))
:qid typing_FStar.Pervasives.all_wp_h))

:named typing_FStar.Pervasives.all_wp_h))
;;;;;;;;;;;;;;;;_: FStar.Pervasives.all_post_h h a -> FStar.Pervasives.all_pre_h h
(declare-fun Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5))

:named kinding_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5))

:named FStar.Pervasives_pre_typing_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,49-619,62)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(FStar.Pervasives.all_post_h @x2
@x1))
(HasType (ApplyTT @x0
@x3)
(FStar.Pervasives.all_pre_h @x2)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5))

:named FStar.Pervasives_interpretation_Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_wp_h
;;; Fact-ids: Name FStar.Pervasives.all_wp_h; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(619,4-619,12)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.all_wp_h @x0
@x1)
(Tm_arrow_1cd90c71d90a216d9fb0ba0321a1d3b5 @x1
@x0))
 

:pattern ((FStar.Pervasives.all_wp_h @x0
@x1))
:qid equation_FStar.Pervasives.all_wp_h))

:named equation_FStar.Pervasives.all_wp_h))

; </end encoding FStar.Pervasives.all_wp_h>


; <Start encoding FStar.Pervasives.all_return>

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

;;;;;;;;;;;;;;;;heap: Type -> a: Type -> x: a -> p: FStar.Pervasives.all_post_h heap a -> _: heap -> Prims.GTot Type
(declare-fun Tm_arrow_3f61557667800fb54cc62e48a5201f9d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3f61557667800fb54cc62e48a5201f9d
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_3f61557667800fb54cc62e48a5201f9d
Tm_type)
:named kinding_Tm_arrow_3f61557667800fb54cc62e48a5201f9d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_3f61557667800fb54cc62e48a5201f9d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_3f61557667800fb54cc62e48a5201f9d))
:qid FStar.Pervasives_pre_typing_Tm_arrow_3f61557667800fb54cc62e48a5201f9d))

:named FStar.Pervasives_pre_typing_Tm_arrow_3f61557667800fb54cc62e48a5201f9d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_3f61557667800fb54cc62e48a5201f9d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x2)
(HasType @x4
(FStar.Pervasives.all_post_h @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x2))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_3f61557667800fb54cc62e48a5201f9d))
:qid FStar.Pervasives_interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d))

:named FStar.Pervasives_interpretation_Tm_arrow_3f61557667800fb54cc62e48a5201f9d))
(declare-fun FStar.Pervasives.all_return@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_return@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.all_return @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_return@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.all_return))

:named token_correspondence_FStar.Pervasives.all_return))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_return@tok
Tm_arrow_3f61557667800fb54cc62e48a5201f9d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_return@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.all_return @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.all_return @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.all_return.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_return@tok))
:qid function_token_typing_FStar.Pervasives.all_return))

:named function_token_typing_FStar.Pervasives.all_return))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
(FStar.Pervasives.all_post_h @x0
@x1)))
(HasType (FStar.Pervasives.all_return @x0
@x1
@x2
@x3)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0)))
 

:pattern ((FStar.Pervasives.all_return @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.all_return))

:named typing_FStar.Pervasives.all_return))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_return
;;; Fact-ids: Name FStar.Pervasives.all_return; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(624,4-624,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.all_return @x0
@x1
@x2
@x3)
(ApplyTT @x3
(FStar.Pervasives.V @x1
@x2)))
 

:pattern ((FStar.Pervasives.all_return @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.all_return))

:named equation_FStar.Pervasives.all_return))

; </end encoding FStar.Pervasives.all_return>


; <Start encoding FStar.Pervasives.all_bind_wp>

;;;;;;;;;;;;;;;;_: a -> Prims.GTot (FStar.Pervasives.all_wp_h heap b)
(declare-fun Tm_arrow_b567b509414635f00096b9b1c3e30b57 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b567b509414635f00096b9b1c3e30b57
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_b567b509414635f00096b9b1c3e30b57))

:named kinding_Tm_arrow_b567b509414635f00096b9b1c3e30b57))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x2
@x3
@x4)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_b567b509414635f00096b9b1c3e30b57))

:named FStar.Pervasives_pre_typing_Tm_arrow_b567b509414635f00096b9b1c3e30b57))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b567b509414635f00096b9b1c3e30b57
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(633,23-633,40)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x3)
(HasType (ApplyTT @x0
@x4)
(FStar.Pervasives.all_wp_h @x2
@x1)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_b567b509414635f00096b9b1c3e30b57.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x1
@x2
@x3)))
:qid FStar.Pervasives_interpretation_Tm_arrow_b567b509414635f00096b9b1c3e30b57))

:named FStar.Pervasives_interpretation_Tm_arrow_b567b509414635f00096b9b1c3e30b57))
(declare-fun FStar.Pervasives.all_bind_wp (Term Term Term Term Term Term Term) Term)

;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     b: Type ->     wp1: FStar.Pervasives.all_wp_h heap a ->     wp2: (_: a -> Prims.GTot (FStar.Pervasives.all_wp_h heap b)) ->     p: FStar.Pervasives.all_post_h heap b ->     h0: heap   -> Prims.GTot Type
(declare-fun Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22
Tm_type)
:named kinding_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))
:qid FStar.Pervasives_pre_typing_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))

:named FStar.Pervasives_pre_typing_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x5
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x3
@x1
@x2))
(HasType @x6
(FStar.Pervasives.all_post_h @x1
@x3))
(HasType @x7
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x5
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x3
@x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(636,11-636,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x5
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x3
@x1
@x2))
(HasType @x6
(FStar.Pervasives.all_post_h @x1
@x3)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))
:qid FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))

:named FStar.Pervasives_interpretation_Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))
(declare-fun FStar.Pervasives.all_bind_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.all_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_bind_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.all_bind_wp))

:named token_correspondence_FStar.Pervasives.all_bind_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_bind_wp@tok
Tm_arrow_6ac18e25eb49f55ae0ce9c14679ecc22))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_bind_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.all_bind_wp @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.all_bind_wp @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.all_bind_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_bind_wp@tok))
:qid function_token_typing_FStar.Pervasives.all_bind_wp))

:named function_token_typing_FStar.Pervasives.all_bind_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x0
@x1))
(HasType @x4
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x2
@x0
@x1))
(HasType @x5
(FStar.Pervasives.all_post_h @x0
@x2))
(HasType @x6
@x0))
(HasType (FStar.Pervasives.all_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Tm_type))
 

:pattern ((FStar.Pervasives.all_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.all_bind_wp))

:named typing_FStar.Pervasives.all_bind_wp))

;;;;;;;;;;;;;;;;ra: FStar.Pervasives.result a -> h1: heap -> Prims.GTot Type
(declare-fun Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e))

:named kinding_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e))

:named FStar.Pervasives_pre_typing_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x3
(FStar.Pervasives.result @x2))
(HasType @x4
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x3)
@x4)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(613,64-613,69)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(FStar.Pervasives.result @x2))
(IsTotFun (ApplyTT @x0
@x3)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e))

:named FStar.Pervasives_interpretation_Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e))
(declare-fun Tm_abs_35ddc99cefc0079215f6f6ab3c58856d (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_35ddc99cefc0079215f6f6ab3c58856d
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(638,8-641,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(638,8-641,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (HasType (Tm_abs_35ddc99cefc0079215f6f6ab3c58856d @x0
@x1
@x2
@x3
@x4)
(Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x3
@x4))
 

:pattern ((Tm_abs_35ddc99cefc0079215f6f6ab3c58856d @x0
@x1
@x2
@x3
@x4))
:qid typing_Tm_abs_35ddc99cefc0079215f6f6ab3c58856d))

:named typing_Tm_abs_35ddc99cefc0079215f6f6ab3c58856d))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_35ddc99cefc0079215f6f6ab3c58856d
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(638,8-641,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(638,8-641,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (Tm_abs_35ddc99cefc0079215f6f6ab3c58856d @x2
@x3
@x4
@x5
@x6)
@x0)
@x1)
(let ((@lb7 @x0))
(ite (is-FStar.Pervasives.V @lb7)
(ApplyTT (ApplyTT (ApplyTT @x2
(FStar.Pervasives.V_v @lb7))
@x3)
@x1)
(ite (is-FStar.Pervasives.E @lb7)
(ApplyTT (ApplyTT @x3
(FStar.Pervasives.E @x4
(FStar.Pervasives.E_e @lb7)))
@x1)
(ite (is-FStar.Pervasives.Err @lb7)
(ApplyTT (ApplyTT @x3
(FStar.Pervasives.Err @x4
(FStar.Pervasives.Err_msg @lb7)))
@x1)
Tm_unit)))))
 

:pattern ((ApplyTT (ApplyTT (Tm_abs_35ddc99cefc0079215f6f6ab3c58856d @x2
@x3
@x4
@x5
@x6)
@x0)
@x1))
:qid interpretation_Tm_abs_35ddc99cefc0079215f6f6ab3c58856d))

:named interpretation_Tm_abs_35ddc99cefc0079215f6f6ab3c58856d))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_bind_wp
;;; Fact-ids: Name FStar.Pervasives.all_bind_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(629,4-629,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.all_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(ApplyTT (ApplyTT @x3
(Tm_abs_35ddc99cefc0079215f6f6ab3c58856d @x4
@x5
@x2
@x0
@x1))
@x6))
 

:pattern ((FStar.Pervasives.all_bind_wp @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid equation_FStar.Pervasives.all_bind_wp))

:named equation_FStar.Pervasives.all_bind_wp))

; </end encoding FStar.Pervasives.all_bind_wp>


; <Start encoding FStar.Pervasives.all_if_then_else>

(declare-fun FStar.Pervasives.all_if_then_else (Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     p: Type ->     wp_then: FStar.Pervasives.all_wp_h heap a ->     wp_else: FStar.Pervasives.all_wp_h heap a ->     post: FStar.Pervasives.all_post_h heap a ->     h0: heap   -> Prims.logical
(declare-fun Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4
Tm_type)
:named kinding_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))
:qid FStar.Pervasives_pre_typing_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))

:named FStar.Pervasives_pre_typing_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x5
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x6
(FStar.Pervasives.all_post_h @x1
@x2))
(HasType @x7
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x5
(FStar.Pervasives.all_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(167,39-167,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,23-651,25)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x5
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x6
(FStar.Pervasives.all_post_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4.7))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))
:qid FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))

:named FStar.Pervasives_interpretation_Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))
(declare-fun FStar.Pervasives.all_if_then_else@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_if_then_else@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid token_correspondence_FStar.Pervasives.all_if_then_else))

:named token_correspondence_FStar.Pervasives.all_if_then_else))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_if_then_else@tok
Tm_arrow_491eee2c8dc4eab4d420326a8285d2c4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_if_then_else@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.all_if_then_else @x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((FStar.Pervasives.all_if_then_else @x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid function_token_typing_FStar.Pervasives.all_if_then_else.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_if_then_else@tok))
:qid function_token_typing_FStar.Pervasives.all_if_then_else))

:named function_token_typing_FStar.Pervasives.all_if_then_else))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x0
@x1))
(HasType @x4
(FStar.Pervasives.all_wp_h @x0
@x1))
(HasType @x5
(FStar.Pervasives.all_post_h @x0
@x1))
(HasType @x6
@x0))
(HasType (FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Prims.logical))
 

:pattern ((FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid typing_FStar.Pervasives.all_if_then_else))

:named typing_FStar.Pervasives.all_if_then_else))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_if_then_else
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (Valid (FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,7-651,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,7-651,50)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,7-651,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,7-651,22)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,7-651,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,7-651,22)
(ApplyTT (ApplyTT @x3
@x5)
@x6)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,26-651,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,26-651,50)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,27-651,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,27-651,29)
(not 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(647,14-647,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,28-651,29)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(647,14-647,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,28-651,29)
@x2
)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,34-651,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,34-651,49)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,34-651,49); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(651,34-651,49)
(ApplyTT (ApplyTT @x4
@x5)
@x6)
)
)
)
)
 

:pattern ((FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6))
:qid equation_FStar.Pervasives.all_if_then_else))

:named equation_FStar.Pervasives.all_if_then_else))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_if_then_else
;;; Fact-ids: Name FStar.Pervasives.all_if_then_else; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(646,4-646,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6)
(Prims.l_and (ApplyTT (ApplyTT @x3
@x5)
@x6)
(Prims.l_imp (Prims.l_not @x2)
(ApplyTT (ApplyTT @x4
@x5)
@x6))))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.all_if_then_else @x0
@x1
@x2
@x3
@x4
@x5
@x6)
Prims.unit))
:qid defn_equation_FStar.Pervasives.all_if_then_else))

:named defn_equation_FStar.Pervasives.all_if_then_else))

; </end encoding FStar.Pervasives.all_if_then_else>


; <Start encoding FStar.Pervasives.all_ite_wp>

(declare-fun FStar.Pervasives.all_ite_wp (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     wp: FStar.Pervasives.all_wp_h heap a ->     post: FStar.Pervasives.all_post_h heap a ->     h0: heap   -> Prims.logical
(declare-fun Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7
Tm_type)
:named kinding_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))
:qid FStar.Pervasives_pre_typing_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))

:named FStar.Pervasives_pre_typing_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x4
(FStar.Pervasives.all_post_h @x1
@x2))
(HasType @x5
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x4
(FStar.Pervasives.all_post_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))
:qid FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))

:named FStar.Pervasives_interpretation_Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))
(declare-fun FStar.Pervasives.all_ite_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_ite_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_ite_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.all_ite_wp))

:named token_correspondence_FStar.Pervasives.all_ite_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_ite_wp@tok
Tm_arrow_20fdb4e6d0c32f949f55e39a059913a7))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_ite_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.all_ite_wp @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.all_ite_wp @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.all_ite_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_ite_wp@tok))
:qid function_token_typing_FStar.Pervasives.all_ite_wp))

:named function_token_typing_FStar.Pervasives.all_ite_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.all_wp_h @x0
@x1))
(HasType @x3
(FStar.Pervasives.all_post_h @x0
@x1))
(HasType @x4
@x0))
(HasType (FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4)
Prims.logical))
 

:pattern ((FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.all_ite_wp))

:named typing_FStar.Pervasives.all_ite_wp))



(declare-fun Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,26-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,26-657,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x0
@x1
@x2
@x3)
(Tm_arrow_ca5db633696caf7e0cd44c11654eed8b @x3))
 

:pattern ((Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4))

:named typing_Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,26-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,26-657,87)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x1
@x2
@x3
@x4)
@x0)
(Prims.l_Forall @x1
(Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x2
@x0
@x3
@x1)))
 

:pattern ((ApplyTT (Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4))

:named interpretation_Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.result @x3)
(Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x2
@x1
@x0
@x3)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88)
(forall ((@x4 Term) (@x5 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,87)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77)
(ApplyTT (ApplyTT @x1
@x4)
@x5)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87)
(ApplyTT (ApplyTT @x0
@x4)
@x5)
)
)

 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid l_quant_interp_b752ad44ef66e6e0aceecd363b1c9453.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.result @x3)
(Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x2
@x1
@x0
@x3))))
:qid l_quant_interp_b752ad44ef66e6e0aceecd363b1c9453))

:named l_quant_interp_b752ad44ef66e6e0aceecd363b1c9453))
;;;;;;;;;;;;;;;;k: FStar.Pervasives.all_post_h heap a -> Prims.GTot Type
(declare-fun Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912))

:named kinding_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912))

:named FStar.Pervasives_pre_typing_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,40-265,45); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,9-656,31)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(FStar.Pervasives.all_post_h @x2
@x1))
(HasType (ApplyTT @x0
@x3)
Tm_type))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912))

:named FStar.Pervasives_interpretation_Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912))
(declare-fun Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 (Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (HasType (Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x0
@x1
@x2
@x3
@x4)
(Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x3
@x4))
 

:pattern ((Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x0
@x1
@x2
@x3
@x4))
:qid typing_Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130))

:named typing_Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x1
@x2
@x3
@x4
@x5)
@x0)
(Prims.l_imp (Prims.l_Forall (FStar.Pervasives.result @x4)
(Tm_abs_b4b0cf2e42901b42be235caa84bfc7f4 @x5
@x1
@x0
@x4))
(ApplyTT (ApplyTT @x2
@x0)
@x3)))
 

:pattern ((ApplyTT (Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x1
@x2
@x3
@x4
@x5)
@x0))
:qid interpretation_Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130))

:named interpretation_Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.all_post_h @x4
@x3)
(Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x2
@x1
@x0
@x3
@x4)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
(FStar.Pervasives.all_post_h @x4
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88)
(forall ((@x6 Term) (@x7 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,87)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77)
(ApplyTT (ApplyTT @x2
@x6)
@x7)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87)
(ApplyTT (ApplyTT @x5
@x6)
@x7)
)
)

 

:pattern ((ApplyTT (ApplyTT @x5
@x6)
@x7))
:qid l_quant_interp_9a02894a52ee6a6e7bd2089482d8b6e9.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100)
(ApplyTT (ApplyTT @x1
@x5)
@x0)
)
)
 
;;no pats
:qid l_quant_interp_9a02894a52ee6a6e7bd2089482d8b6e9.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.all_post_h @x4
@x3)
(Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x2
@x1
@x0
@x3
@x4))))
:qid l_quant_interp_9a02894a52ee6a6e7bd2089482d8b6e9))

:named l_quant_interp_9a02894a52ee6a6e7bd2089482d8b6e9))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_ite_wp
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (Valid (FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(656,2-657,100)
(forall ((@x5 Term))
 (! (implies (and (HasType @x5
(FStar.Pervasives.all_post_h @x0
@x1))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,4-657,88)
(forall ((@x6 Term) (@x7 Term))
 (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,87)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,69-657,77)
(ApplyTT (ApplyTT @x3
@x6)
@x7)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,82-657,87)
(ApplyTT (ApplyTT @x5
@x6)
@x7)
)
)

 

:pattern ((ApplyTT (ApplyTT @x5
@x6)
@x7))
:qid equation_FStar.Pervasives.all_ite_wp.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(657,93-657,100)
(ApplyTT (ApplyTT @x2
@x5)
@x4)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.all_ite_wp.1))
)
 

:pattern ((FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4))
:qid equation_FStar.Pervasives.all_ite_wp))

:named equation_FStar.Pervasives.all_ite_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_ite_wp
;;; Fact-ids: Name FStar.Pervasives.all_ite_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(655,4-655,14)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4)
(Prims.l_Forall (FStar.Pervasives.all_post_h @x0
@x1)
(Tm_abs_aa90876ffd60a4411fdca7eeeb8f6130 @x3
@x2
@x4
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.all_ite_wp @x0
@x1
@x2
@x3
@x4)
Prims.unit))
:qid defn_equation_FStar.Pervasives.all_ite_wp))

:named defn_equation_FStar.Pervasives.all_ite_wp))

; </end encoding FStar.Pervasives.all_ite_wp>


; <Start encoding FStar.Pervasives.all_stronger>

(declare-fun FStar.Pervasives.all_stronger (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     wp1: FStar.Pervasives.all_wp_h heap a ->     wp2: FStar.Pervasives.all_wp_h heap a   -> Prims.logical
(declare-fun Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68
Tm_type)
:named kinding_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,10-662,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))
:qid FStar.Pervasives_pre_typing_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))

:named FStar.Pervasives_pre_typing_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,10-662,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,10-662,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x1
@x2))
(HasType @x4
(FStar.Pervasives.all_wp_h @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,10-662,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,10-662,32)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,10-662,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))
:qid FStar.Pervasives_interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))

:named FStar.Pervasives_interpretation_Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))
(declare-fun FStar.Pervasives.all_stronger@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_stronger@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_stronger@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.all_stronger))

:named token_correspondence_FStar.Pervasives.all_stronger))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_stronger@tok
Tm_arrow_073b21d0ec8edf2dda32907b45ec5f68))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_stronger@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.all_stronger @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.all_stronger @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.all_stronger.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_stronger@tok))
:qid function_token_typing_FStar.Pervasives.all_stronger))

:named function_token_typing_FStar.Pervasives.all_stronger))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.all_wp_h @x0
@x1))
(HasType @x3
(FStar.Pervasives.all_wp_h @x0
@x1)))
(HasType (FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3)
Prims.logical))
 

:pattern ((FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.all_stronger))

:named typing_FStar.Pervasives.all_stronger))



(declare-fun Tm_abs_61b202c6a5250875acb8de09e14bb21a (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_61b202c6a5250875acb8de09e14bb21a
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,33-662,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,33-662,63)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (HasType (Tm_abs_61b202c6a5250875acb8de09e14bb21a @x0
@x1
@x2
@x3)
(Tm_arrow_f7466eb55fd31463cdfb5b4251fe1912 @x2
@x3))
 

:pattern ((Tm_abs_61b202c6a5250875acb8de09e14bb21a @x0
@x1
@x2
@x3))
:qid typing_Tm_abs_61b202c6a5250875acb8de09e14bb21a))

:named typing_Tm_abs_61b202c6a5250875acb8de09e14bb21a))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_61b202c6a5250875acb8de09e14bb21a
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,33-662,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,33-662,63)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (Tm_abs_61b202c6a5250875acb8de09e14bb21a @x1
@x2
@x3
@x4)
@x0)
(Prims.l_Forall @x4
(Tm_abs_13c1fbac4d566537e0d0aac54993e867 @x1
@x0
@x2
@x4)))
 

:pattern ((ApplyTT (Tm_abs_61b202c6a5250875acb8de09e14bb21a @x1
@x2
@x3
@x4)
@x0))
:qid interpretation_Tm_abs_61b202c6a5250875acb8de09e14bb21a))

:named interpretation_Tm_abs_61b202c6a5250875acb8de09e14bb21a))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,2-662,64); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,2-662,64)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (Valid (Prims.l_Forall (FStar.Pervasives.all_post_h @x3
@x2)
(Tm_abs_61b202c6a5250875acb8de09e14bb21a @x1
@x0
@x2
@x3)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,2-662,64); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,2-662,64)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(FStar.Pervasives.all_post_h @x3
@x2))
(HasType @x5
@x3)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51)
(ApplyTT (ApplyTT @x1
@x4)
@x5)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63)
(ApplyTT (ApplyTT @x0
@x4)
@x5)
)
)
 
;;no pats
:qid l_quant_interp_ca860125878c4233ff674c9bf32051f4.1))
)
 

:pattern ((Valid (Prims.l_Forall (FStar.Pervasives.all_post_h @x3
@x2)
(Tm_abs_61b202c6a5250875acb8de09e14bb21a @x1
@x0
@x2
@x3))))
:qid l_quant_interp_ca860125878c4233ff674c9bf32051f4))

:named l_quant_interp_ca860125878c4233ff674c9bf32051f4))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_stronger
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (Valid (FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,2-662,64); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,2-662,64)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(FStar.Pervasives.all_post_h @x0
@x1))
(HasType @x5
@x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,44-662,51)
(ApplyTT (ApplyTT @x2
@x4)
@x5)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(662,56-662,63)
(ApplyTT (ApplyTT @x3
@x4)
@x5)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.all_stronger.1))
)
 

:pattern ((FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.all_stronger))

:named equation_FStar.Pervasives.all_stronger))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_stronger
;;; Fact-ids: Name FStar.Pervasives.all_stronger; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(661,4-661,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3)
(Prims.l_Forall (FStar.Pervasives.all_post_h @x0
@x1)
(Tm_abs_61b202c6a5250875acb8de09e14bb21a @x2
@x3
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.all_stronger @x0
@x1
@x2
@x3)
Prims.unit))
:qid defn_equation_FStar.Pervasives.all_stronger))

:named defn_equation_FStar.Pervasives.all_stronger))

; </end encoding FStar.Pervasives.all_stronger>


; <Start encoding FStar.Pervasives.all_close_wp>


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

;;;;;;;;;;;;;;;;heap: Type ->     a: Type ->     b: Type ->     wp: (_: b -> Prims.GTot (FStar.Pervasives.all_wp_h heap a)) ->     p: FStar.Pervasives.all_post_h heap a ->     h: heap   -> Prims.logical
(declare-fun Tm_arrow_803d195802308e8beadf04438d3a6508 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_803d195802308e8beadf04438d3a6508
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_803d195802308e8beadf04438d3a6508
Tm_type)
:named kinding_Tm_arrow_803d195802308e8beadf04438d3a6508))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_803d195802308e8beadf04438d3a6508)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_803d195802308e8beadf04438d3a6508))
:qid FStar.Pervasives_pre_typing_Tm_arrow_803d195802308e8beadf04438d3a6508))

:named FStar.Pervasives_pre_typing_Tm_arrow_803d195802308e8beadf04438d3a6508))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_803d195802308e8beadf04438d3a6508)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x2
@x1
@x3))
(HasType @x5
(FStar.Pervasives.all_post_h @x1
@x2))
(HasType @x6
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x2
@x1
@x3)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,15-671,21)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
Tm_type)
(HasType @x4
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x2
@x1
@x3))
(HasType @x5
(FStar.Pervasives.all_post_h @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_803d195802308e8beadf04438d3a6508))
:qid FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508))

:named FStar.Pervasives_interpretation_Tm_arrow_803d195802308e8beadf04438d3a6508))
(declare-fun FStar.Pervasives.all_close_wp@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_close_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_close_wp@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Pervasives.all_close_wp))

:named token_correspondence_FStar.Pervasives.all_close_wp))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_close_wp@tok
Tm_arrow_803d195802308e8beadf04438d3a6508))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_close_wp@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.all_close_wp @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Pervasives.all_close_wp @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Pervasives.all_close_wp.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_close_wp@tok))
:qid function_token_typing_FStar.Pervasives.all_close_wp))

:named function_token_typing_FStar.Pervasives.all_close_wp))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_arrow_b567b509414635f00096b9b1c3e30b57 @x1
@x0
@x2))
(HasType @x4
(FStar.Pervasives.all_post_h @x0
@x1))
(HasType @x5
@x0))
(HasType (FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5)
Prims.logical))
 

:pattern ((FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Pervasives.all_close_wp))

:named typing_FStar.Pervasives.all_close_wp))




;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_close_wp
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Valid (FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,7-671,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,7-671,32)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,23-671,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,23-671,31)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,23-671,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(671,23-671,31)
(ApplyTT (ApplyTT (ApplyTT @x3
@x6)
@x4)
@x5)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.all_close_wp.1))
)
 

:pattern ((FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5))
:qid equation_FStar.Pervasives.all_close_wp))

:named equation_FStar.Pervasives.all_close_wp))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_close_wp
;;; Fact-ids: Name FStar.Pervasives.all_close_wp; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(666,4-666,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5)
(Prims.l_Forall @x2
(Tm_abs_bd152fc5c12cc6aa125ccf543aa53813 @x3
@x4
@x5
@x2)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.all_close_wp @x0
@x1
@x2
@x3
@x4
@x5)
Prims.unit))
:qid defn_equation_FStar.Pervasives.all_close_wp))

:named defn_equation_FStar.Pervasives.all_close_wp))

; </end encoding FStar.Pervasives.all_close_wp>


; <Start encoding FStar.Pervasives.all_trivial>

(declare-fun FStar.Pervasives.all_trivial (Term Term Term) Term)
;;;;;;;;;;;;;;;;heap: Type -> a: Type -> wp: FStar.Pervasives.all_wp_h heap a -> Prims.logical
(declare-fun Tm_arrow_957927b0d25001784693eee8b2182308 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_957927b0d25001784693eee8b2182308
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_957927b0d25001784693eee8b2182308
Tm_type)
:named kinding_Tm_arrow_957927b0d25001784693eee8b2182308))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,63-675,73)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_957927b0d25001784693eee8b2182308)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_957927b0d25001784693eee8b2182308))
:qid FStar.Pervasives_pre_typing_Tm_arrow_957927b0d25001784693eee8b2182308))

:named FStar.Pervasives_pre_typing_Tm_arrow_957927b0d25001784693eee8b2182308))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_957927b0d25001784693eee8b2182308
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,63-675,73)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_957927b0d25001784693eee8b2182308)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,63-675,73)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.all_wp_h @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.logical))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_957927b0d25001784693eee8b2182308.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,63-675,73)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_957927b0d25001784693eee8b2182308.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,63-675,73)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_957927b0d25001784693eee8b2182308.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_957927b0d25001784693eee8b2182308))
:qid FStar.Pervasives_interpretation_Tm_arrow_957927b0d25001784693eee8b2182308))

:named FStar.Pervasives_interpretation_Tm_arrow_957927b0d25001784693eee8b2182308))
(declare-fun FStar.Pervasives.all_trivial@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_trivial@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.all_trivial @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_trivial@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.all_trivial))

:named token_correspondence_FStar.Pervasives.all_trivial))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.all_trivial@tok
Tm_arrow_957927b0d25001784693eee8b2182308))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.all_trivial@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.all_trivial @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.all_trivial @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.all_trivial.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.all_trivial@tok))
:qid function_token_typing_FStar.Pervasives.all_trivial))

:named function_token_typing_FStar.Pervasives.all_trivial))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.all_wp_h @x0
@x1)))
(HasType (FStar.Pervasives.all_trivial @x0
@x1
@x2)
Prims.logical))
 

:pattern ((FStar.Pervasives.all_trivial @x0
@x1
@x2))
:qid typing_FStar.Pervasives.all_trivial))

:named typing_FStar.Pervasives.all_trivial))

(declare-fun Tm_abs_22e463dbd987016e31d6bc67025a7cd9 (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_22e463dbd987016e31d6bc67025a7cd9
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,91-675,95); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,91-675,95)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x0
@x1)
(Tm_arrow_59cac8a9b1ae3aa9511b8a867f8e934e @x0
@x1))
 

:pattern ((Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x0
@x1))
:qid typing_Tm_abs_22e463dbd987016e31d6bc67025a7cd9))

:named typing_Tm_abs_22e463dbd987016e31d6bc67025a7cd9))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_22e463dbd987016e31d6bc67025a7cd9
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,91-675,95); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,91-675,95)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x2
@x3)
@x0)
@x1)
Prims.l_True)
 

:pattern ((ApplyTT (ApplyTT (Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x2
@x3)
@x0)
@x1))
:qid interpretation_Tm_abs_22e463dbd987016e31d6bc67025a7cd9))

:named interpretation_Tm_abs_22e463dbd987016e31d6bc67025a7cd9))

(declare-fun Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 (Term Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_c7ae205604ad646e5515eb4bea93d3f2
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x0
@x1
@x2)
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x2))
 

:pattern ((Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x0
@x1
@x2))
:qid typing_Tm_abs_c7ae205604ad646e5515eb4bea93d3f2))

:named typing_Tm_abs_c7ae205604ad646e5515eb4bea93d3f2))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_c7ae205604ad646e5515eb4bea93d3f2
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x1
@x2
@x3)
@x0)
(ApplyTT (ApplyTT @x1
(Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x3
@x2))
@x0))
 

:pattern ((ApplyTT (Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x1
@x2
@x3)
@x0))
:qid interpretation_Tm_abs_c7ae205604ad646e5515eb4bea93d3f2))

:named interpretation_Tm_abs_c7ae205604ad646e5515eb4bea93d3f2))


;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (Valid (Prims.l_Forall @x2
(Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x1
@x0
@x2)))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99)
(ApplyTT (ApplyTT @x1
(Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x2
@x0))
@x3)
)
)
 
;;no pats
:qid l_quant_interp_d0e9a98c755b2ecef2b31902b72adec3.1))
)
 

:pattern ((Valid (Prims.l_Forall @x2
(Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x1
@x0
@x2))))
:qid l_quant_interp_d0e9a98c755b2ecef2b31902b72adec3))

:named l_quant_interp_d0e9a98c755b2ecef2b31902b72adec3))


;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_trivial
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (Valid (FStar.Pervasives.all_trivial @x0
@x1
@x2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,55-675,100)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,75-675,99)
(ApplyTT (ApplyTT @x2
(Tm_abs_22e463dbd987016e31d6bc67025a7cd9 @x0
@x1))
@x3)
)
)
 
;;no pats
:qid equation_FStar.Pervasives.all_trivial.1))
)
 

:pattern ((FStar.Pervasives.all_trivial @x0
@x1
@x2))
:qid equation_FStar.Pervasives.all_trivial))

:named equation_FStar.Pervasives.all_trivial))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.all_trivial
;;; Fact-ids: Name FStar.Pervasives.all_trivial; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(675,4-675,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.all_trivial @x0
@x1
@x2)
(Prims.l_Forall @x0
(Tm_abs_c7ae205604ad646e5515eb4bea93d3f2 @x2
@x1
@x0)))
 

:pattern ((Prims.subtype_of (FStar.Pervasives.all_trivial @x0
@x1
@x2)
Prims.unit))
:qid defn_equation_FStar.Pervasives.all_trivial))

:named defn_equation_FStar.Pervasives.all_trivial))

; </end encoding FStar.Pervasives.all_trivial>


; <Skipped FStar.Pervasives.ALL_h/>


; <Start encoding FStar.Pervasives.inversion>

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

(declare-fun FStar.Pervasives.inversion@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.inversion@tok
@x0)
(FStar.Pervasives.inversion @x0))
 

:pattern ((ApplyTT FStar.Pervasives.inversion@tok
@x0))
:qid token_correspondence_FStar.Pervasives.inversion))

:named token_correspondence_FStar.Pervasives.inversion))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.inversion@tok
Tm_arrow_ef9cb512a25ee351fa5536d617490497))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.inversion@tok
@x1)
(FStar.Pervasives.inversion @x1))
 

:pattern ((FStar.Pervasives.inversion @x1))
:qid function_token_typing_FStar.Pervasives.inversion.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.inversion@tok))
:qid function_token_typing_FStar.Pervasives.inversion))

:named function_token_typing_FStar.Pervasives.inversion))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(708,4-708,13)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.inversion @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.inversion @x0))
:qid typing_FStar.Pervasives.inversion))

:named typing_FStar.Pervasives.inversion))
;;;;;;;;;;;;;;;;inversion interpretation
;;; Fact-ids: Name FStar.Pervasives.inversion; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (Valid (FStar.Pervasives.inversion @x0))
(forall ((@x1 Term))
 (! (implies (HasTypeZ @x1
@x0)
(HasTypeFuel (SFuel ZFuel)
@x1
@x0))
 

:pattern ((HasTypeZ @x1
@x0))
:qid inversion-interp.1)))
 

:pattern ((FStar.Pervasives.inversion @x0))
:qid inversion-interp))
:named inversion-interp))

; </end encoding FStar.Pervasives.inversion>


; <Start encoding FStar.Pervasives.allow_inversion>

(declare-fun FStar.Pervasives.allow_inversion (Term) Term)
(declare-fun Tm_refine_363615bee79fae5066b7c8bd06c286d0 (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_363615bee79fae5066b7c8bd06c286d0))

:named refinement_kinding_Tm_refine_363615bee79fae5066b7c8bd06c286d0))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x2))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,77-712,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,77-712,88)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,77-712,88); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,77-712,88)
(FStar.Pervasives.inversion @x2)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x2)))
:qid refinement_interpretation_Tm_refine_363615bee79fae5066b7c8bd06c286d0))

:named refinement_interpretation_Tm_refine_363615bee79fae5066b7c8bd06c286d0))
;;;;;;;;;;;;;;;;haseq for Tm_refine_363615bee79fae5066b7c8bd06c286d0
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x0)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x0))))
:qid haseqTm_refine_363615bee79fae5066b7c8bd06c286d0))

:named haseqTm_refine_363615bee79fae5066b7c8bd06c286d0))
;;;;;;;;;;;;;;;;a: Type -> Prims.Pure Prims.unit
(declare-fun Tm_arrow_bcab9cce464ec0f76562bc48c17ba410 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_bcab9cce464ec0f76562bc48c17ba410
Tm_type)
:named kinding_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_bcab9cce464ec0f76562bc48c17ba410)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))
:qid FStar.Pervasives_pre_typing_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))

:named FStar.Pervasives_pre_typing_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_bcab9cce464ec0f76562bc48c17ba410)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,37-712,41)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(HasType (ApplyTT @x0
@x1)
(Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))
:qid FStar.Pervasives_interpretation_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))

:named FStar.Pervasives_interpretation_Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))
(declare-fun FStar.Pervasives.allow_inversion@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.allow_inversion@tok
@x0)
(FStar.Pervasives.allow_inversion @x0))
 

:pattern ((ApplyTT FStar.Pervasives.allow_inversion@tok
@x0))
:qid token_correspondence_FStar.Pervasives.allow_inversion))

:named token_correspondence_FStar.Pervasives.allow_inversion))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.allow_inversion@tok
Tm_arrow_bcab9cce464ec0f76562bc48c17ba410))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.allow_inversion@tok
@x1)
(FStar.Pervasives.allow_inversion @x1))
 

:pattern ((FStar.Pervasives.allow_inversion @x1))
:qid function_token_typing_FStar.Pervasives.allow_inversion.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.allow_inversion@tok))
:qid function_token_typing_FStar.Pervasives.allow_inversion))

:named function_token_typing_FStar.Pervasives.allow_inversion))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.allow_inversion; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(712,4-712,19)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)
(HasType (FStar.Pervasives.allow_inversion @x0)
(Tm_refine_363615bee79fae5066b7c8bd06c286d0 @x0)))
 

:pattern ((FStar.Pervasives.allow_inversion @x0))
:qid typing_FStar.Pervasives.allow_inversion))

:named typing_FStar.Pervasives.allow_inversion))

; </end encoding FStar.Pervasives.allow_inversion>


; <Start encoding 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)
;;;;;;;;;;;;;;;;Lemma: FStar.Pervasives.invertOption
;;; Fact-ids: Name FStar.Pervasives.invertOption; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_type)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,37-717,79); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,37-717,79)
(forall ((@x1 Term))
 (! (implies (HasType @x1
(FStar.Pervasives.Native.option @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,60-717,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,60-717,78)
(or 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,60-717,67); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,60-717,67)
(BoxBool_proj_0 (FStar.Pervasives.Native.uu___is_None @x0
@x1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,71-717,78); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(717,71-717,78)
(BoxBool_proj_0 (FStar.Pervasives.Native.uu___is_Some @x0
@x1))
)
)
 
;;no pats
:qid lemma_FStar.Pervasives.invertOption.1))
)
 

:pattern ((FStar.Pervasives.Native.option @x0))
:qid lemma_FStar.Pervasives.invertOption))
:named lemma_FStar.Pervasives.invertOption))

; </end encoding FStar.Pervasives.invertOption>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.either (Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.either@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.either@x1 (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: 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: Inr
(declare-fun FStar.Pervasives.Inr@tok () Term)
;;;;;;;;;;;;;;;;v: a -> FStar.Pervasives.either a b
(declare-fun Tm_arrow_065da0adeba0c4ae0da1476ececee84c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_065da0adeba0c4ae0da1476ececee84c
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_065da0adeba0c4ae0da1476ececee84c
Tm_type)
:named kinding_Tm_arrow_065da0adeba0c4ae0da1476ececee84c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_065da0adeba0c4ae0da1476ececee84c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_065da0adeba0c4ae0da1476ececee84c))
:qid FStar.Pervasives_pre_typing_Tm_arrow_065da0adeba0c4ae0da1476ececee84c))

:named FStar.Pervasives_pre_typing_Tm_arrow_065da0adeba0c4ae0da1476ececee84c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_065da0adeba0c4ae0da1476ececee84c
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_065da0adeba0c4ae0da1476ececee84c)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(FStar.Pervasives.either @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_065da0adeba0c4ae0da1476ececee84c.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_065da0adeba0c4ae0da1476ececee84c.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,18-721,28)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_065da0adeba0c4ae0da1476ececee84c.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_065da0adeba0c4ae0da1476ececee84c))
:qid FStar.Pervasives_interpretation_Tm_arrow_065da0adeba0c4ae0da1476ececee84c))

:named FStar.Pervasives_interpretation_Tm_arrow_065da0adeba0c4ae0da1476ececee84c))
;;;;;;;;;;;;;;;;v: b -> FStar.Pervasives.either a b
(declare-fun Tm_arrow_c883938642e6d97d79c975d8d94b4aac () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c883938642e6d97d79c975d8d94b4aac
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_c883938642e6d97d79c975d8d94b4aac
Tm_type)
:named kinding_Tm_arrow_c883938642e6d97d79c975d8d94b4aac))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_c883938642e6d97d79c975d8d94b4aac)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_c883938642e6d97d79c975d8d94b4aac))
:qid FStar.Pervasives_pre_typing_Tm_arrow_c883938642e6d97d79c975d8d94b4aac))

:named FStar.Pervasives_pre_typing_Tm_arrow_c883938642e6d97d79c975d8d94b4aac))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c883938642e6d97d79c975d8d94b4aac
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_c883938642e6d97d79c975d8d94b4aac)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
@x2))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(FStar.Pervasives.either @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_c883938642e6d97d79c975d8d94b4aac.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_c883938642e6d97d79c975d8d94b4aac.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,18-722,28)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_c883938642e6d97d79c975d8d94b4aac.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_c883938642e6d97d79c975d8d94b4aac))
:qid FStar.Pervasives_interpretation_Tm_arrow_c883938642e6d97d79c975d8d94b4aac))

:named FStar.Pervasives_interpretation_Tm_arrow_c883938642e6d97d79c975d8d94b4aac))

; <Start encoding FStar.Pervasives.either>


; <start constructor FStar.Pervasives.either>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= 452
(Term_constr_id (FStar.Pervasives.either @x0
@x1)))
 

:pattern ((FStar.Pervasives.either @x0
@x1))
:qid constructor_distinct_FStar.Pervasives.either))

:named constructor_distinct_FStar.Pervasives.either))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.either ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
452)
(exists ((@x0 Term) (@x1 Term))
 (! (= __@x0
(FStar.Pervasives.either @x0
@x1))
 
;;no pats
:qid is-FStar.Pervasives.either))))

; </end constructor FStar.Pervasives.either>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (= 453
(Term_constr_id FStar.Pervasives.either@tok))
:named fresh_token_FStar.Pervasives.either@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.either@tok
@x0)
@x1)
(FStar.Pervasives.either @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.either@tok
@x0)
@x1))

:pattern ((FStar.Pervasives.either @x0
@x1))
:qid token_correspondence_FStar.Pervasives.either@tok))

:named token_correspondence_FStar.Pervasives.either@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.either@tok))
:named pre_kinding_FStar.Pervasives.either@tok))
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (and (IsTotFun FStar.Pervasives.either@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.either@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.either@tok
@x0))
:qid kinding_FStar.Pervasives.either@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type))
(HasType (FStar.Pervasives.either @x0
@x1)
Tm_type))
 

:pattern ((FStar.Pervasives.either @x0
@x1))
:qid kinding_FStar.Pervasives.either@tok.1))
)
:named kinding_FStar.Pervasives.either@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.either @x2
@x3))
(= (FStar.Pervasives.either @x2
@x3)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.either @x2
@x3)))
:qid FStar.Pervasives_pretyping_b33635a76275268b8c60db6fa0677ca6))

:named FStar.Pervasives_pretyping_b33635a76275268b8c60db6fa0677ca6))

; </end encoding FStar.Pervasives.either>


; <Start encoding FStar.Pervasives.Inl>


; <start constructor FStar.Pervasives.Inl>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 459
(Term_constr_id (FStar.Pervasives.Inl @x0
@x1
@x2)))
 

:pattern ((FStar.Pervasives.Inl @x0
@x1
@x2))
:qid constructor_distinct_FStar.Pervasives.Inl))

:named constructor_distinct_FStar.Pervasives.Inl))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Inl_a (FStar.Pervasives.Inl @x0
@x1
@x2))
@x0)
 

:pattern ((FStar.Pervasives.Inl @x0
@x1
@x2))
:qid projection_inverse_FStar.Pervasives.Inl_a))

:named projection_inverse_FStar.Pervasives.Inl_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Inl_b (FStar.Pervasives.Inl @x0
@x1
@x2))
@x1)
 

:pattern ((FStar.Pervasives.Inl @x0
@x1
@x2))
:qid projection_inverse_FStar.Pervasives.Inl_b))

:named projection_inverse_FStar.Pervasives.Inl_b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Inl_v (FStar.Pervasives.Inl @x0
@x1
@x2))
@x2)
 

:pattern ((FStar.Pervasives.Inl @x0
@x1
@x2))
:qid projection_inverse_FStar.Pervasives.Inl_v))

:named projection_inverse_FStar.Pervasives.Inl_v))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Inl ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
459)
(= __@x0
(FStar.Pervasives.Inl (FStar.Pervasives.Inl_a __@x0)
(FStar.Pervasives.Inl_b __@x0)
(FStar.Pervasives.Inl_v __@x0)))))

; </end constructor FStar.Pervasives.Inl>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (= 462
(Term_constr_id FStar.Pervasives.Inl@tok))
:named fresh_token_FStar.Pervasives.Inl@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Inl@tok
Tm_arrow_065da0adeba0c4ae0da1476ececee84c))
 

:pattern ((ApplyTT FStar.Pervasives.Inl@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Inl@tok))
:qid typing_tok_FStar.Pervasives.Inl@tok))

:named typing_tok_FStar.Pervasives.Inl@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Inl@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Inl @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Inl@tok
@x0)
@x1)
@x2))
:qid equality_tok_FStar.Pervasives.Inl@tok))

:named equality_tok_FStar.Pervasives.Inl@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1))
(HasTypeFuel @u0
(FStar.Pervasives.Inl @x1
@x2
@x3)
(FStar.Pervasives.either @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Inl @x1
@x2
@x3)
(FStar.Pervasives.either @x1
@x2)))
:qid data_typing_intro_FStar.Pervasives.Inl@tok))

:named data_typing_intro_FStar.Pervasives.Inl@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inl @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5))
(and (HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x3
@x4)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x1)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inl @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5)))
:qid data_elim_FStar.Pervasives.Inl))

:named data_elim_FStar.Pervasives.Inl))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inl @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(FStar.Pervasives.Inl @x1
@x2
@x3))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inl @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5)))
:qid subterm_ordering_FStar.Pervasives.Inl))

:named subterm_ordering_FStar.Pervasives.Inl))

; </end encoding FStar.Pervasives.Inl>


; <Start encoding FStar.Pervasives.Inr>


; <start constructor FStar.Pervasives.Inr>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 464
(Term_constr_id (FStar.Pervasives.Inr @x0
@x1
@x2)))
 

:pattern ((FStar.Pervasives.Inr @x0
@x1
@x2))
:qid constructor_distinct_FStar.Pervasives.Inr))

:named constructor_distinct_FStar.Pervasives.Inr))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Inr_a (FStar.Pervasives.Inr @x0
@x1
@x2))
@x0)
 

:pattern ((FStar.Pervasives.Inr @x0
@x1
@x2))
:qid projection_inverse_FStar.Pervasives.Inr_a))

:named projection_inverse_FStar.Pervasives.Inr_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Inr_b (FStar.Pervasives.Inr @x0
@x1
@x2))
@x1)
 

:pattern ((FStar.Pervasives.Inr @x0
@x1
@x2))
:qid projection_inverse_FStar.Pervasives.Inr_b))

:named projection_inverse_FStar.Pervasives.Inr_b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.Inr_v (FStar.Pervasives.Inr @x0
@x1
@x2))
@x2)
 

:pattern ((FStar.Pervasives.Inr @x0
@x1
@x2))
:qid projection_inverse_FStar.Pervasives.Inr_v))

:named projection_inverse_FStar.Pervasives.Inr_v))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Inr ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
464)
(= __@x0
(FStar.Pervasives.Inr (FStar.Pervasives.Inr_a __@x0)
(FStar.Pervasives.Inr_b __@x0)
(FStar.Pervasives.Inr_v __@x0)))))

; </end constructor FStar.Pervasives.Inr>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! (= 467
(Term_constr_id FStar.Pervasives.Inr@tok))
:named fresh_token_FStar.Pervasives.Inr@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Inr@tok
Tm_arrow_c883938642e6d97d79c975d8d94b4aac))
 

:pattern ((ApplyTT FStar.Pervasives.Inr@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Inr@tok))
:qid typing_tok_FStar.Pervasives.Inr@tok))

:named typing_tok_FStar.Pervasives.Inr@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Inr@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.Inr @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Inr@tok
@x0)
@x1)
@x2))
:qid equality_tok_FStar.Pervasives.Inr@tok))

:named equality_tok_FStar.Pervasives.Inr@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x2))
(HasTypeFuel @u0
(FStar.Pervasives.Inr @x1
@x2
@x3)
(FStar.Pervasives.either @x1
@x2)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Inr @x1
@x2
@x3)
(FStar.Pervasives.either @x1
@x2)))
:qid data_typing_intro_FStar.Pervasives.Inr@tok))

:named data_typing_intro_FStar.Pervasives.Inr@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inr @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5))
(and (HasTypeFuel @u0
@x5
Tm_type)
(HasTypeFuel @u0
@x3
@x5)
(HasTypeFuel @u0
@x4
Tm_type)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
Tm_type)
(HasTypeFuel @u0
@x3
@x2)))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inr @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5)))
:qid data_elim_FStar.Pervasives.Inr))

:named data_elim_FStar.Pervasives.Inr))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inr @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x3
(FStar.Pervasives.Inr @x1
@x2
@x3))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Inr @x1
@x2
@x3)
(FStar.Pervasives.either @x4
@x5)))
:qid subterm_ordering_FStar.Pervasives.Inr))

:named subterm_ordering_FStar.Pervasives.Inr))

; </end encoding FStar.Pervasives.Inr>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.either; Namespace FStar.Pervasives; Name FStar.Pervasives.Inl; Namespace FStar.Pervasives; Name FStar.Pervasives.Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,5-720,11)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(FStar.Pervasives.either @x2
@x3))
(or (and (is-FStar.Pervasives.Inl @x1)
(= @x2
(FStar.Pervasives.Inl_a @x1))
(= @x3
(FStar.Pervasives.Inl_b @x1)))
(and (is-FStar.Pervasives.Inr @x1)
(= @x2
(FStar.Pervasives.Inr_a @x1))
(= @x3
(FStar.Pervasives.Inr_b @x1)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
@x1
(FStar.Pervasives.either @x2
@x3)))
:qid fuel_guarded_inversion_FStar.Pervasives.either))

:named fuel_guarded_inversion_FStar.Pervasives.either))

; </end encoding >


; <Start encoding FStar.Pervasives.either__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: either__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.either__uu___haseq; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq @x1)))
(Valid (Prims.hasEq (FStar.Pervasives.either @x0
@x1))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.either @x0
@x1)))
:qid assumption_FStar.Pervasives.either__uu___haseq))
:named assumption_FStar.Pervasives.either__uu___haseq))

; </end encoding FStar.Pervasives.either__uu___haseq>


; <Start encoding FStar.Pervasives.uu___is_Inl>

(declare-fun FStar.Pervasives.uu___is_Inl (Term Term Term) Term)
;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.either a b -> Prims.bool
(declare-fun Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d
Tm_type)
:named kinding_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
:qid FStar.Pervasives_pre_typing_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
:named FStar.Pervasives_pre_typing_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(FStar.Pervasives.either @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d.3))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
:qid FStar.Pervasives_interpretation_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
:named FStar.Pervasives_interpretation_Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))
(declare-fun FStar.Pervasives.uu___is_Inl@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Inl@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.uu___is_Inl @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Inl@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.uu___is_Inl))

:named token_correspondence_FStar.Pervasives.uu___is_Inl))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Inl@tok
Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Inl@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.uu___is_Inl @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.uu___is_Inl @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.uu___is_Inl.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Inl@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Inl))

:named function_token_typing_FStar.Pervasives.uu___is_Inl))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.either @x0
@x1)))
(HasType (FStar.Pervasives.uu___is_Inl @x0
@x1
@x2)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Inl @x0
@x1
@x2))
:qid typing_FStar.Pervasives.uu___is_Inl))

:named typing_FStar.Pervasives.uu___is_Inl))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inl; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.uu___is_Inl @x0
@x1
@x2)
(BoxBool (is-FStar.Pervasives.Inl @x2)))
 

:pattern ((FStar.Pervasives.uu___is_Inl @x0
@x1
@x2))
:qid disc_equation_FStar.Pervasives.Inl))

:named disc_equation_FStar.Pervasives.Inl))

; </end encoding FStar.Pervasives.uu___is_Inl>


; <Skipped FStar.Pervasives.uu___is_Inl/>


; <Start encoding FStar.Pervasives.__proj__Inl__item__v>

(declare-fun Tm_refine_85e0cc884f8457202f90cd77f23733ba (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_85e0cc884f8457202f90cd77f23733ba @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_85e0cc884f8457202f90cd77f23733ba @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_85e0cc884f8457202f90cd77f23733ba))

:named refinement_kinding_Tm_refine_85e0cc884f8457202f90cd77f23733ba))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_85e0cc884f8457202f90cd77f23733ba @x2
@x3))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.either @x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_Inl @x2
@x3
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_85e0cc884f8457202f90cd77f23733ba @x2
@x3)))
:qid refinement_interpretation_Tm_refine_85e0cc884f8457202f90cd77f23733ba))

:named refinement_interpretation_Tm_refine_85e0cc884f8457202f90cd77f23733ba))
;;;;;;;;;;;;;;;;haseq for Tm_refine_85e0cc884f8457202f90cd77f23733ba
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,4-721,7)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_85e0cc884f8457202f90cd77f23733ba @x0
@x1)))
(Valid (Prims.hasEq (FStar.Pervasives.either @x0
@x1))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_85e0cc884f8457202f90cd77f23733ba @x0
@x1))))
:qid haseqTm_refine_85e0cc884f8457202f90cd77f23733ba))

:named haseqTm_refine_85e0cc884f8457202f90cd77f23733ba))
(declare-fun FStar.Pervasives.__proj__Inl__item__v (Term Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.either a b {Inl? _} -> a
(declare-fun Tm_arrow_a80e0750277867ba1a434ad3bba8702d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a80e0750277867ba1a434ad3bba8702d
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_a80e0750277867ba1a434ad3bba8702d
Tm_type)
:named kinding_Tm_arrow_a80e0750277867ba1a434ad3bba8702d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a80e0750277867ba1a434ad3bba8702d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a80e0750277867ba1a434ad3bba8702d))
:qid FStar.Pervasives_pre_typing_Tm_arrow_a80e0750277867ba1a434ad3bba8702d))

:named FStar.Pervasives_pre_typing_Tm_arrow_a80e0750277867ba1a434ad3bba8702d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a80e0750277867ba1a434ad3bba8702d
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a80e0750277867ba1a434ad3bba8702d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_85e0cc884f8457202f90cd77f23733ba @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_a80e0750277867ba1a434ad3bba8702d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_a80e0750277867ba1a434ad3bba8702d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,12-720,13)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_a80e0750277867ba1a434ad3bba8702d.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a80e0750277867ba1a434ad3bba8702d))
:qid FStar.Pervasives_interpretation_Tm_arrow_a80e0750277867ba1a434ad3bba8702d))

:named FStar.Pervasives_interpretation_Tm_arrow_a80e0750277867ba1a434ad3bba8702d))
(declare-fun FStar.Pervasives.__proj__Inl__item__v@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Inl__item__v@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.__proj__Inl__item__v @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Inl__item__v@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.__proj__Inl__item__v))

:named token_correspondence_FStar.Pervasives.__proj__Inl__item__v))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Inl__item__v@tok
Tm_arrow_a80e0750277867ba1a434ad3bba8702d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Inl__item__v@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.__proj__Inl__item__v @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.__proj__Inl__item__v @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.__proj__Inl__item__v.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Inl__item__v@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Inl__item__v))

:named function_token_typing_FStar.Pervasives.__proj__Inl__item__v))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_85e0cc884f8457202f90cd77f23733ba @x0
@x1)))
(HasType (FStar.Pervasives.__proj__Inl__item__v @x0
@x1
@x2)
@x0))
 

:pattern ((FStar.Pervasives.__proj__Inl__item__v @x0
@x1
@x2))
:qid typing_FStar.Pervasives.__proj__Inl__item__v))

:named typing_FStar.Pervasives.__proj__Inl__item__v))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Inl__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(721,10-721,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.__proj__Inl__item__v @x0
@x1
@x2)
(FStar.Pervasives.Inl_v @x2))
 

:pattern ((FStar.Pervasives.__proj__Inl__item__v @x0
@x1
@x2))
:qid proj_equation_FStar.Pervasives.Inl_v))

:named proj_equation_FStar.Pervasives.Inl_v))

; </end encoding FStar.Pervasives.__proj__Inl__item__v>


; <Skipped FStar.Pervasives.__proj__Inl__item__v/>


; <Start encoding 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)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Inr@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.uu___is_Inr @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Inr@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.uu___is_Inr))

:named token_correspondence_FStar.Pervasives.uu___is_Inr))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Inr@tok
Tm_arrow_af0c68f1e39d4d6020c0873b16730c7d))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Inr@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.uu___is_Inr @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.uu___is_Inr @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.uu___is_Inr.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Inr@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Inr))

:named function_token_typing_FStar.Pervasives.uu___is_Inr))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(FStar.Pervasives.either @x0
@x1)))
(HasType (FStar.Pervasives.uu___is_Inr @x0
@x1
@x2)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Inr @x0
@x1
@x2))
:qid typing_FStar.Pervasives.uu___is_Inr))

:named typing_FStar.Pervasives.uu___is_Inr))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Inr; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.uu___is_Inr @x0
@x1
@x2)
(BoxBool (is-FStar.Pervasives.Inr @x2)))
 

:pattern ((FStar.Pervasives.uu___is_Inr @x0
@x1
@x2))
:qid disc_equation_FStar.Pervasives.Inr))

:named disc_equation_FStar.Pervasives.Inr))

; </end encoding FStar.Pervasives.uu___is_Inr>


; <Skipped FStar.Pervasives.uu___is_Inr/>


; <Start encoding FStar.Pervasives.__proj__Inr__item__v>

(declare-fun Tm_refine_8f1f5f564dae90240db429de2eb41517 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_8f1f5f564dae90240db429de2eb41517 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_8f1f5f564dae90240db429de2eb41517 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_8f1f5f564dae90240db429de2eb41517))

:named refinement_kinding_Tm_refine_8f1f5f564dae90240db429de2eb41517))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_8f1f5f564dae90240db429de2eb41517 @x2
@x3))
(and (HasTypeFuel @u0
@x1
(FStar.Pervasives.either @x2
@x3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_Inr @x2
@x3
@x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_8f1f5f564dae90240db429de2eb41517 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_8f1f5f564dae90240db429de2eb41517))

:named refinement_interpretation_Tm_refine_8f1f5f564dae90240db429de2eb41517))
;;;;;;;;;;;;;;;;haseq for Tm_refine_8f1f5f564dae90240db429de2eb41517
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,4-722,7)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_8f1f5f564dae90240db429de2eb41517 @x0
@x1)))
(Valid (Prims.hasEq (FStar.Pervasives.either @x0
@x1))))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_8f1f5f564dae90240db429de2eb41517 @x0
@x1))))
:qid haseqTm_refine_8f1f5f564dae90240db429de2eb41517))

:named haseqTm_refine_8f1f5f564dae90240db429de2eb41517))
(declare-fun FStar.Pervasives.__proj__Inr__item__v (Term Term Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.either a b {Inr? _} -> b
(declare-fun Tm_arrow_df618db6b42762940f198036c8a56200 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_df618db6b42762940f198036c8a56200
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_df618db6b42762940f198036c8a56200
Tm_type)
:named kinding_Tm_arrow_df618db6b42762940f198036c8a56200))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_df618db6b42762940f198036c8a56200)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_df618db6b42762940f198036c8a56200))
:qid FStar.Pervasives_pre_typing_Tm_arrow_df618db6b42762940f198036c8a56200))

:named FStar.Pervasives_pre_typing_Tm_arrow_df618db6b42762940f198036c8a56200))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_df618db6b42762940f198036c8a56200
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_df618db6b42762940f198036c8a56200)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_8f1f5f564dae90240db429de2eb41517 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_df618db6b42762940f198036c8a56200.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_df618db6b42762940f198036c8a56200.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(720,14-720,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_df618db6b42762940f198036c8a56200.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_df618db6b42762940f198036c8a56200))
:qid FStar.Pervasives_interpretation_Tm_arrow_df618db6b42762940f198036c8a56200))

:named FStar.Pervasives_interpretation_Tm_arrow_df618db6b42762940f198036c8a56200))
(declare-fun FStar.Pervasives.__proj__Inr__item__v@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Inr__item__v@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.__proj__Inr__item__v @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Inr__item__v@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.__proj__Inr__item__v))

:named token_correspondence_FStar.Pervasives.__proj__Inr__item__v))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Inr__item__v@tok
Tm_arrow_df618db6b42762940f198036c8a56200))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Inr__item__v@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.__proj__Inr__item__v @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.__proj__Inr__item__v @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.__proj__Inr__item__v.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Inr__item__v@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Inr__item__v))

:named function_token_typing_FStar.Pervasives.__proj__Inr__item__v))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_8f1f5f564dae90240db429de2eb41517 @x0
@x1)))
(HasType (FStar.Pervasives.__proj__Inr__item__v @x0
@x1
@x2)
@x1))
 

:pattern ((FStar.Pervasives.__proj__Inr__item__v @x0
@x1
@x2))
:qid typing_FStar.Pervasives.__proj__Inr__item__v))

:named typing_FStar.Pervasives.__proj__Inr__item__v))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Inr__item__v; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(722,10-722,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.__proj__Inr__item__v @x0
@x1
@x2)
(FStar.Pervasives.Inr_v @x2))
 

:pattern ((FStar.Pervasives.__proj__Inr__item__v @x0
@x1
@x2))
:qid proj_equation_FStar.Pervasives.Inr_v))

:named proj_equation_FStar.Pervasives.Inr_v))

; </end encoding FStar.Pervasives.__proj__Inr__item__v>


; <Skipped FStar.Pervasives.__proj__Inr__item__v/>


; <Start encoding FStar.Pervasives.dfst>


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


(declare-fun FStar.Pervasives.dfst@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.dfst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dfst@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.dfst @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dfst@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.dfst))

:named token_correspondence_FStar.Pervasives.dfst))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.dfst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.dfst@tok
Tm_arrow_26c013ffba39d4f7eeb4bcc80d2d4e22))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dfst@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.dfst @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.dfst @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.dfst.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.dfst@tok))
:qid function_token_typing_FStar.Pervasives.dfst))

:named function_token_typing_FStar.Pervasives.dfst))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.dfst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Prims.dtuple2 @x0
@x1)))
(HasType (FStar.Pervasives.dfst @x0
@x1
@x2)
@x0))
 

:pattern ((FStar.Pervasives.dfst @x0
@x1
@x2))
:qid typing_FStar.Pervasives.dfst))

:named typing_FStar.Pervasives.dfst))

;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.dfst
;;; Fact-ids: Name FStar.Pervasives.dfst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(725,4-725,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.dfst @x0
@x1
@x2)
(Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2))
 

:pattern ((FStar.Pervasives.dfst @x0
@x1
@x2))
:qid equation_FStar.Pervasives.dfst))

:named equation_FStar.Pervasives.dfst))

; </end encoding FStar.Pervasives.dfst>


; <Start encoding FStar.Pervasives.dsnd>


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


(declare-fun FStar.Pervasives.dsnd@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.dsnd; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dsnd@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.dsnd @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dsnd@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.dsnd))

:named token_correspondence_FStar.Pervasives.dsnd))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.dsnd; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.dsnd@tok
Tm_arrow_870cc7701a0d9a8a2d6fb92427a97d66))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dsnd@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.dsnd @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.dsnd @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.dsnd.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.dsnd@tok))
:qid function_token_typing_FStar.Pervasives.dsnd))

:named function_token_typing_FStar.Pervasives.dsnd))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.dsnd; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Prims.dtuple2 @x0
@x1)))
(HasType (FStar.Pervasives.dsnd @x0
@x1
@x2)
(ApplyTT @x1
(Prims.__proj__Mkdtuple2__item___1 @x0
@x1
@x2))))
 

:pattern ((FStar.Pervasives.dsnd @x0
@x1
@x2))
:qid typing_FStar.Pervasives.dsnd))

:named typing_FStar.Pervasives.dsnd))

;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.dsnd
;;; Fact-ids: Name FStar.Pervasives.dsnd; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(729,4-729,8)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (FStar.Pervasives.dsnd @x0
@x1
@x2)
(Prims.__proj__Mkdtuple2__item___2 @x0
@x1
@x2))
 

:pattern ((FStar.Pervasives.dsnd @x0
@x1
@x2))
:qid equation_FStar.Pervasives.dsnd))

:named equation_FStar.Pervasives.dsnd))

; </end encoding FStar.Pervasives.dsnd>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.dtuple3 (Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple3@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple3@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple3@x2 (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: Mkdtuple3
(declare-fun FStar.Pervasives.Mkdtuple3@tok () Term)

;;;;;;;;;;;;;;;;x: a -> _: b x -> Prims.GTot Type
(declare-fun Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335))

:named kinding_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x3)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335))

:named FStar.Pervasives_pre_typing_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74)
(forall ((@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x3
@x2)
(HasType @x4
(ApplyTT @x1
@x3)))
(HasType (ApplyTT (ApplyTT @x0
@x3)
@x4)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT @x0
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,70-735,74)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(IsTotFun (ApplyTT @x0
@x3)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x2)))
:qid FStar.Pervasives_interpretation_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335))

:named FStar.Pervasives_interpretation_Tm_arrow_0b6559e6ff3addf84b0c2880affbb335))




;;;;;;;;;;;;;;;;_1: a -> _2: b _1 -> _3: c _1 _2 -> FStar.Pervasives.dtuple3 a b c
(declare-fun Tm_arrow_8423f67df62f9e824c55756f9e26058d () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8423f67df62f9e824c55756f9e26058d
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_8423f67df62f9e824c55756f9e26058d
Tm_type)
:named kinding_Tm_arrow_8423f67df62f9e824c55756f9e26058d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8423f67df62f9e824c55756f9e26058d)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8423f67df62f9e824c55756f9e26058d))
:qid FStar.Pervasives_pre_typing_Tm_arrow_8423f67df62f9e824c55756f9e26058d))

:named FStar.Pervasives_pre_typing_Tm_arrow_8423f67df62f9e824c55756f9e26058d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8423f67df62f9e824c55756f9e26058d)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
@x1)
(HasType @x5
(ApplyTT @x2
@x4))
(HasType @x6
(ApplyTT (ApplyTT @x3
@x4)
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,52-736,65)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
@x1)
(HasType @x5
(ApplyTT @x2
@x4)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8423f67df62f9e824c55756f9e26058d))
:qid FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d))

:named FStar.Pervasives_interpretation_Tm_arrow_8423f67df62f9e824c55756f9e26058d))

; <Start encoding FStar.Pervasives.dtuple3>


; <start constructor FStar.Pervasives.dtuple3>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= 500
(Term_constr_id (FStar.Pervasives.dtuple3 @x0
@x1
@x2)))
 

:pattern ((FStar.Pervasives.dtuple3 @x0
@x1
@x2))
:qid constructor_distinct_FStar.Pervasives.dtuple3))

:named constructor_distinct_FStar.Pervasives.dtuple3))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.dtuple3 ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
500)
(exists ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= __@x0
(FStar.Pervasives.dtuple3 @x0
@x1
@x2))
 
;;no pats
:qid is-FStar.Pervasives.dtuple3))))

; </end constructor FStar.Pervasives.dtuple3>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! (= 501
(Term_constr_id FStar.Pervasives.dtuple3@tok))
:named fresh_token_FStar.Pervasives.dtuple3@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dtuple3@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.dtuple3 @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dtuple3@tok
@x0)
@x1)
@x2))

:pattern ((FStar.Pervasives.dtuple3 @x0
@x1
@x2))
:qid token_correspondence_FStar.Pervasives.dtuple3@tok))

:named token_correspondence_FStar.Pervasives.dtuple3@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.dtuple3@tok))
:named pre_kinding_FStar.Pervasives.dtuple3@tok))
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! (and (IsTotFun FStar.Pervasives.dtuple3@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.dtuple3@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.dtuple3@tok
@x0))
:qid kinding_FStar.Pervasives.dtuple3@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.dtuple3@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.dtuple3@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.dtuple3@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0)))
(HasType (FStar.Pervasives.dtuple3 @x0
@x1
@x2)
Tm_type))
 

:pattern ((FStar.Pervasives.dtuple3 @x0
@x1
@x2))
:qid kinding_FStar.Pervasives.dtuple3@tok.2))
)
:named kinding_FStar.Pervasives.dtuple3@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.dtuple3 @x2
@x3
@x4))
(= (FStar.Pervasives.dtuple3 @x2
@x3
@x4)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.dtuple3 @x2
@x3
@x4)))
:qid FStar.Pervasives_pretyping_a5299c19d6dd1bceb5aa4630d018b183))

:named FStar.Pervasives_pretyping_a5299c19d6dd1bceb5aa4630d018b183))

; </end encoding FStar.Pervasives.dtuple3>


; <Start encoding FStar.Pervasives.Mkdtuple3>


; <start constructor FStar.Pervasives.Mkdtuple3>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= 511
(Term_constr_id (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5)))
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid constructor_distinct_FStar.Pervasives.Mkdtuple3))

:named constructor_distinct_FStar.Pervasives.Mkdtuple3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Mkdtuple3_a (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x0)
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Mkdtuple3_a))

:named projection_inverse_FStar.Pervasives.Mkdtuple3_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Mkdtuple3_b (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x1)
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Mkdtuple3_b))

:named projection_inverse_FStar.Pervasives.Mkdtuple3_b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Mkdtuple3_c (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x2)
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Mkdtuple3_c))

:named projection_inverse_FStar.Pervasives.Mkdtuple3_c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Mkdtuple3__1 (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x3)
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Mkdtuple3__1))

:named projection_inverse_FStar.Pervasives.Mkdtuple3__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Mkdtuple3__2 (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x4)
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Mkdtuple3__2))

:named projection_inverse_FStar.Pervasives.Mkdtuple3__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (FStar.Pervasives.Mkdtuple3__3 (FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
@x5)
 

:pattern ((FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
:qid projection_inverse_FStar.Pervasives.Mkdtuple3__3))

:named projection_inverse_FStar.Pervasives.Mkdtuple3__3))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Mkdtuple3 ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
511)
(= __@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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! (= 518
(Term_constr_id FStar.Pervasives.Mkdtuple3@tok))
:named fresh_token_FStar.Pervasives.Mkdtuple3@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Mkdtuple3@tok
Tm_arrow_8423f67df62f9e824c55756f9e26058d))
 

:pattern ((ApplyTT FStar.Pervasives.Mkdtuple3@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Mkdtuple3@tok))
:qid typing_tok_FStar.Pervasives.Mkdtuple3@tok))

:named typing_tok_FStar.Pervasives.Mkdtuple3@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Mkdtuple3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.Mkdtuple3 @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Mkdtuple3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid equality_tok_FStar.Pervasives.Mkdtuple3@tok))

:named equality_tok_FStar.Pervasives.Mkdtuple3@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasTypeFuel @u0
@x4
@x1)
(HasTypeFuel @u0
@x5
(ApplyTT @x2
@x4))
(HasTypeFuel @u0
@x6
(ApplyTT (ApplyTT @x3
@x4)
@x5)))
(HasTypeFuel @u0
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
:qid data_typing_intro_FStar.Pervasives.Mkdtuple3@tok))

:named data_typing_intro_FStar.Pervasives.Mkdtuple3@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.dtuple3 @x7
@x8
@x9))
(and (HasTypeFuel @u0
@x9
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasTypeFuel @u0
@x6
(ApplyTT (ApplyTT @x9
@x4)
@x5))
(HasTypeFuel @u0
@x8
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x8
@x1))
(HasTypeFuel @u0
@x5
(ApplyTT @x8
@x4))
(HasTypeFuel @u0
@x7
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x7))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x7))
(HasTypeFuel @u0
@x4
@x7)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasTypeFuel @u0
@x4
@x1)
(HasTypeFuel @u0
@x5
(ApplyTT @x2
@x4))
(HasTypeFuel @u0
@x6
(ApplyTT (ApplyTT @x3
@x4)
@x5))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.dtuple3 @x7
@x8
@x9)))
:qid data_elim_FStar.Pervasives.Mkdtuple3))

:named data_elim_FStar.Pervasives.Mkdtuple3))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.dtuple3 @x7
@x8
@x9))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x4
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x5
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x6
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple3 @x1
@x2
@x3
@x4
@x5
@x6)
(FStar.Pervasives.dtuple3 @x7
@x8
@x9)))
:qid subterm_ordering_FStar.Pervasives.Mkdtuple3))

:named subterm_ordering_FStar.Pervasives.Mkdtuple3))

; </end encoding FStar.Pervasives.Mkdtuple3>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.dtuple3; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,5-735,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.dtuple3 @x2
@x3
@x4))
(and (is-FStar.Pervasives.Mkdtuple3 @x1)
(= @x2
(FStar.Pervasives.Mkdtuple3_a @x1))
(= @x3
(FStar.Pervasives.Mkdtuple3_b @x1))
(= @x4
(FStar.Pervasives.Mkdtuple3_c @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.dtuple3 @x2
@x3
@x4)))
:qid fuel_guarded_inversion_FStar.Pervasives.dtuple3))

:named fuel_guarded_inversion_FStar.Pervasives.dtuple3))

; </end encoding >


; <Start encoding FStar.Pervasives.dtuple3__uu___haseq>



;;;;;;;;;;;;;;;;Assumption: dtuple3__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.dtuple3__uu___haseq; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(forall ((@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x3
@x0)
(HasType @x4
(ApplyTT @x1
@x3))
(HasType @x5
(ApplyTT (ApplyTT @x2
@x3)
@x4)))
(and (Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq (ApplyTT @x1
@x3)))
(Valid (Prims.hasEq (ApplyTT (ApplyTT @x2
@x3)
@x4)))))
 
;;no pats
:qid assumption_FStar.Pervasives.dtuple3__uu___haseq.1)))
(Valid (Prims.hasEq (FStar.Pervasives.dtuple3 @x0
@x1
@x2))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.dtuple3 @x0
@x1
@x2)))
:qid assumption_FStar.Pervasives.dtuple3__uu___haseq))
:named assumption_FStar.Pervasives.dtuple3__uu___haseq))

; </end encoding FStar.Pervasives.dtuple3__uu___haseq>


; <Start encoding FStar.Pervasives.uu___is_Mkdtuple3>



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


;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple3 a b c -> Prims.bool
(declare-fun Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04
Tm_type)
:named kinding_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
:qid FStar.Pervasives_pre_typing_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
:named FStar.Pervasives_pre_typing_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04.4))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
:qid FStar.Pervasives_interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
:named FStar.Pervasives_interpretation_Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))
(declare-fun FStar.Pervasives.uu___is_Mkdtuple3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Mkdtuple3@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.uu___is_Mkdtuple3 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Mkdtuple3@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.uu___is_Mkdtuple3))

:named token_correspondence_FStar.Pervasives.uu___is_Mkdtuple3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Mkdtuple3@tok
Tm_arrow_70452cb82cd0a282ca9a2dbeb54c1b04))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Mkdtuple3@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.uu___is_Mkdtuple3 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.uu___is_Mkdtuple3 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.uu___is_Mkdtuple3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Mkdtuple3@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Mkdtuple3))

:named function_token_typing_FStar.Pervasives.uu___is_Mkdtuple3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(FStar.Pervasives.dtuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.uu___is_Mkdtuple3 @x0
@x1
@x2
@x3)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Mkdtuple3 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.uu___is_Mkdtuple3))

:named typing_FStar.Pervasives.uu___is_Mkdtuple3))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,4-736,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.uu___is_Mkdtuple3 @x0
@x1
@x2
@x3)
(BoxBool (is-FStar.Pervasives.Mkdtuple3 @x3)))
 

:pattern ((FStar.Pervasives.uu___is_Mkdtuple3 @x0
@x1
@x2
@x3))
:qid disc_equation_FStar.Pervasives.Mkdtuple3))

:named disc_equation_FStar.Pervasives.Mkdtuple3))

; </end encoding FStar.Pervasives.uu___is_Mkdtuple3>


; <Skipped FStar.Pervasives.uu___is_Mkdtuple3/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple3__item___1>



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


;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple3 a b c -> a
(declare-fun Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3
Tm_type)
:named kinding_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))
:qid FStar.Pervasives_pre_typing_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))

:named FStar.Pervasives_pre_typing_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(735,14-735,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))
:qid FStar.Pervasives_interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))

:named FStar.Pervasives_interpretation_Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))
(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___1@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___1@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple3__item___1))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple3__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple3__item___1@tok
Tm_arrow_255f0cfe499b1d2e9836e157bce1dba3))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___1@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple3__item___1 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___1 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple3__item___1@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___1))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(FStar.Pervasives.dtuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3)
@x0))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.__proj__Mkdtuple3__item___1))

:named typing_FStar.Pervasives.__proj__Mkdtuple3__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,16-736,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3)
(FStar.Pervasives.Mkdtuple3__1 @x3))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3))
:qid proj_equation_FStar.Pervasives.Mkdtuple3__1))

:named proj_equation_FStar.Pervasives.Mkdtuple3__1))

; </end encoding FStar.Pervasives.__proj__Mkdtuple3__item___1>


; <Skipped FStar.Pervasives.__proj__Mkdtuple3__item___1/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple3__item___2>



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


;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple3 a b c -> b (Mkdtuple3?._1 projectee)
(declare-fun Tm_arrow_ea1ded11f7d194a26e812f407333a011 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ea1ded11f7d194a26e812f407333a011
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_ea1ded11f7d194a26e812f407333a011
Tm_type)
:named kinding_Tm_arrow_ea1ded11f7d194a26e812f407333a011))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ea1ded11f7d194a26e812f407333a011)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ea1ded11f7d194a26e812f407333a011))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ea1ded11f7d194a26e812f407333a011))

:named FStar.Pervasives_pre_typing_Tm_arrow_ea1ded11f7d194a26e812f407333a011))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ea1ded11f7d194a26e812f407333a011)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(ApplyTT @x2
(FStar.Pervasives.__proj__Mkdtuple3__item___1 @x1
@x2
@x3
@x4))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,29-736,33)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ea1ded11f7d194a26e812f407333a011))
:qid FStar.Pervasives_interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011))

:named FStar.Pervasives_interpretation_Tm_arrow_ea1ded11f7d194a26e812f407333a011))
(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___2@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.__proj__Mkdtuple3__item___2 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___2@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple3__item___2))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple3__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple3__item___2@tok
Tm_arrow_ea1ded11f7d194a26e812f407333a011))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___2@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple3__item___2 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___2 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple3__item___2@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___2))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(FStar.Pervasives.dtuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.__proj__Mkdtuple3__item___2 @x0
@x1
@x2
@x3)
(ApplyTT @x1
(FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3))))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___2 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.__proj__Mkdtuple3__item___2))

:named typing_FStar.Pervasives.__proj__Mkdtuple3__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,25-736,27)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple3__item___2 @x0
@x1
@x2
@x3)
(FStar.Pervasives.Mkdtuple3__2 @x3))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___2 @x0
@x1
@x2
@x3))
:qid proj_equation_FStar.Pervasives.Mkdtuple3__2))

:named proj_equation_FStar.Pervasives.Mkdtuple3__2))

; </end encoding FStar.Pervasives.__proj__Mkdtuple3__item___2>


; <Skipped FStar.Pervasives.__proj__Mkdtuple3__item___2/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple3__item___3>



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


;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple3 a b c -> c (Mkdtuple3?._1 projectee) (Mkdtuple3?._2 projectee)
(declare-fun Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e
Tm_type)
:named kinding_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))
:qid FStar.Pervasives_pre_typing_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))

:named FStar.Pervasives_pre_typing_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(FStar.Pervasives.dtuple3 @x1
@x2
@x3)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(ApplyTT (ApplyTT @x3
(FStar.Pervasives.__proj__Mkdtuple3__item___1 @x1
@x2
@x3
@x4))
(FStar.Pervasives.__proj__Mkdtuple3__item___2 @x1
@x2
@x3
@x4))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,41-736,48)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))
:qid FStar.Pervasives_interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))

:named FStar.Pervasives_interpretation_Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))
(declare-fun FStar.Pervasives.__proj__Mkdtuple3__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___3@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.__proj__Mkdtuple3__item___3 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___3@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple3__item___3))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple3__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple3__item___3@tok
Tm_arrow_1d7ad5cfa0fff643640e3f74466d283e))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple3__item___3@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple3__item___3 @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___3 @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple3__item___3@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___3))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple3__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(FStar.Pervasives.dtuple3 @x0
@x1
@x2)))
(HasType (FStar.Pervasives.__proj__Mkdtuple3__item___3 @x0
@x1
@x2
@x3)
(ApplyTT (ApplyTT @x2
(FStar.Pervasives.__proj__Mkdtuple3__item___1 @x0
@x1
@x2
@x3))
(FStar.Pervasives.__proj__Mkdtuple3__item___2 @x0
@x1
@x2
@x3))))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___3 @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.__proj__Mkdtuple3__item___3))

:named typing_FStar.Pervasives.__proj__Mkdtuple3__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple3__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(736,37-736,39)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple3__item___3 @x0
@x1
@x2
@x3)
(FStar.Pervasives.Mkdtuple3__3 @x3))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple3__item___3 @x0
@x1
@x2
@x3))
:qid proj_equation_FStar.Pervasives.Mkdtuple3__3))

:named proj_equation_FStar.Pervasives.Mkdtuple3__3))

; </end encoding FStar.Pervasives.__proj__Mkdtuple3__item___3>


; <Skipped FStar.Pervasives.__proj__Mkdtuple3__item___3/>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.dtuple4 (Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple4@x0 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple4@x1 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple4@x2 (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.dtuple4@x3 (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: Mkdtuple4
(declare-fun FStar.Pervasives.Mkdtuple4@tok () Term)


;;;;;;;;;;;;;;;;x: a -> y: b x -> z: c x y -> Prims.GTot Type
(declare-fun Tm_arrow_af8eda99ba3685403be22a88669dcb35 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_af8eda99ba3685403be22a88669dcb35
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_af8eda99ba3685403be22a88669dcb35))

:named kinding_Tm_arrow_af8eda99ba3685403be22a88669dcb35))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x3
@x4)))
:qid FStar.Pervasives_pre_typing_Tm_arrow_af8eda99ba3685403be22a88669dcb35))

:named FStar.Pervasives_pre_typing_Tm_arrow_af8eda99ba3685403be22a88669dcb35))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_af8eda99ba3685403be22a88669dcb35
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46)
(forall ((@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x4
@x3)
(HasType @x5
(ApplyTT @x2
@x4))
(HasType @x6
(ApplyTT (ApplyTT @x1
@x4)
@x5)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x4)
@x5)
@x6)
Tm_type))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_af8eda99ba3685403be22a88669dcb35.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x3)
(IsTotFun (ApplyTT @x0
@x4)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_af8eda99ba3685403be22a88669dcb35.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(742,42-742,46)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@x3)
(HasType @x5
(ApplyTT @x2
@x4)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_af8eda99ba3685403be22a88669dcb35.3))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x1
@x2
@x3)))
:qid FStar.Pervasives_interpretation_Tm_arrow_af8eda99ba3685403be22a88669dcb35))

:named FStar.Pervasives_interpretation_Tm_arrow_af8eda99ba3685403be22a88669dcb35))






;;;;;;;;;;;;;;;;_1: a -> _2: b _1 -> _3: c _1 _2 -> _4: d _1 _2 _3 -> FStar.Pervasives.dtuple4 a b c d
(declare-fun Tm_arrow_cef44a6056754f192c2446237c4c1408 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_cef44a6056754f192c2446237c4c1408
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_cef44a6056754f192c2446237c4c1408
Tm_type)
:named kinding_Tm_arrow_cef44a6056754f192c2446237c4c1408))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_cef44a6056754f192c2446237c4c1408)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_cef44a6056754f192c2446237c4c1408))
:qid FStar.Pervasives_pre_typing_Tm_arrow_cef44a6056754f192c2446237c4c1408))

:named FStar.Pervasives_pre_typing_Tm_arrow_cef44a6056754f192c2446237c4c1408))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_cef44a6056754f192c2446237c4c1408)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
@x1)
(HasType @x6
(ApplyTT @x2
@x5))
(HasType @x7
(ApplyTT (ApplyTT @x3
@x5)
@x6))
(HasType @x8
(ApplyTT (ApplyTT (ApplyTT @x4
@x5)
@x6)
@x7)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8)
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
@x8))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.6))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
@x1)
(HasType @x6
(ApplyTT @x2
@x5)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.7))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,72-743,87)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
@x1)
(HasType @x6
(ApplyTT @x2
@x5))
(HasType @x7
(ApplyTT (ApplyTT @x3
@x5)
@x6)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408.8))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_cef44a6056754f192c2446237c4c1408))
:qid FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408))

:named FStar.Pervasives_interpretation_Tm_arrow_cef44a6056754f192c2446237c4c1408))

; <Start encoding FStar.Pervasives.dtuple4>


; <start constructor FStar.Pervasives.dtuple4>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= 569
(Term_constr_id (FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
 

:pattern ((FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3))
:qid constructor_distinct_FStar.Pervasives.dtuple4))

:named constructor_distinct_FStar.Pervasives.dtuple4))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.dtuple4 ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
569)
(exists ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= __@x0
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3))
 
;;no pats
:qid is-FStar.Pervasives.dtuple4))))

; </end constructor FStar.Pervasives.dtuple4>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! (= 570
(Term_constr_id FStar.Pervasives.dtuple4@tok))
:named fresh_token_FStar.Pervasives.dtuple4@tok))
;;;;;;;;;;;;;;;;name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dtuple4@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dtuple4@tok
@x0)
@x1)
@x2)
@x3))

:pattern ((FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3))
:qid token_correspondence_FStar.Pervasives.dtuple4@tok))

:named token_correspondence_FStar.Pervasives.dtuple4@tok))
;;;;;;;;;;;;;;;;kinding
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! (is-Tm_arrow (PreType FStar.Pervasives.dtuple4@tok))
:named pre_kinding_FStar.Pervasives.dtuple4@tok))
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! (and (IsTotFun FStar.Pervasives.dtuple4@tok)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term))
 (! (IsTotFun (ApplyTT FStar.Pervasives.dtuple4@tok
@x0))
 

:pattern ((ApplyTT FStar.Pervasives.dtuple4@tok
@x0))
:qid kinding_FStar.Pervasives.dtuple4@tok))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term) (@x1 Term))
 (! (IsTotFun (ApplyTT (ApplyTT FStar.Pervasives.dtuple4@tok
@x0)
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.dtuple4@tok
@x0)
@x1))
:qid kinding_FStar.Pervasives.dtuple4@tok.1))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (IsTotFun (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dtuple4@tok
@x0)
@x1)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.dtuple4@tok
@x0)
@x1)
@x2))
:qid kinding_FStar.Pervasives.dtuple4@tok.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0)))
(HasType (FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)
Tm_type))
 

:pattern ((FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3))
:qid kinding_FStar.Pervasives.dtuple4@tok.3))
)
:named kinding_FStar.Pervasives.dtuple4@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@x0 Term) (@u1 Fuel) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel @u1
@x0
(FStar.Pervasives.dtuple4 @x2
@x3
@x4
@x5))
(= (FStar.Pervasives.dtuple4 @x2
@x3
@x4
@x5)
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
(FStar.Pervasives.dtuple4 @x2
@x3
@x4
@x5)))
:qid FStar.Pervasives_pretyping_cb2c0bca2c2aabdf2d195b0740c049bd))

:named FStar.Pervasives_pretyping_cb2c0bca2c2aabdf2d195b0740c049bd))

; </end encoding FStar.Pervasives.dtuple4>


; <Start encoding FStar.Pervasives.Mkdtuple4>


; <start constructor FStar.Pervasives.Mkdtuple4>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= 582
(Term_constr_id (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7)))
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid constructor_distinct_FStar.Pervasives.Mkdtuple4))

:named constructor_distinct_FStar.Pervasives.Mkdtuple4))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4_a (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x0)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4_a))

:named projection_inverse_FStar.Pervasives.Mkdtuple4_a))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4_b (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x1)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4_b))

:named projection_inverse_FStar.Pervasives.Mkdtuple4_b))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4_c (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x2)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4_c))

:named projection_inverse_FStar.Pervasives.Mkdtuple4_c))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4_d (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x3)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4_d))

:named projection_inverse_FStar.Pervasives.Mkdtuple4_d))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4__1 (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x4)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4__1))

:named projection_inverse_FStar.Pervasives.Mkdtuple4__1))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4__2 (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x5)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4__2))

:named projection_inverse_FStar.Pervasives.Mkdtuple4__2))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4__3 (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x6)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4__3))

:named projection_inverse_FStar.Pervasives.Mkdtuple4__3))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (FStar.Pervasives.Mkdtuple4__4 (FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
@x7)
 

:pattern ((FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
:qid projection_inverse_FStar.Pervasives.Mkdtuple4__4))

:named projection_inverse_FStar.Pervasives.Mkdtuple4__4))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Mkdtuple4 ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
582)
(= __@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>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! (= 591
(Term_constr_id FStar.Pervasives.Mkdtuple4@tok))
:named fresh_token_FStar.Pervasives.Mkdtuple4@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Mkdtuple4@tok
Tm_arrow_cef44a6056754f192c2446237c4c1408))
 

:pattern ((ApplyTT FStar.Pervasives.Mkdtuple4@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Mkdtuple4@tok))
:qid typing_tok_FStar.Pervasives.Mkdtuple4@tok))

:named typing_tok_FStar.Pervasives.Mkdtuple4@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Mkdtuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7)
(FStar.Pervasives.Mkdtuple4 @x0
@x1
@x2
@x3
@x4
@x5
@x6
@x7))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.Mkdtuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
@x7))
:qid equality_tok_FStar.Pervasives.Mkdtuple4@tok))

:named equality_tok_FStar.Pervasives.Mkdtuple4@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasTypeFuel @u0
@x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasTypeFuel @u0
@x5
@x1)
(HasTypeFuel @u0
@x6
(ApplyTT @x2
@x5))
(HasTypeFuel @u0
@x7
(ApplyTT (ApplyTT @x3
@x5)
@x6))
(HasTypeFuel @u0
@x8
(ApplyTT (ApplyTT (ApplyTT @x4
@x5)
@x6)
@x7)))
(HasTypeFuel @u0
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
:qid data_typing_intro_FStar.Pervasives.Mkdtuple4@tok))

:named data_typing_intro_FStar.Pervasives.Mkdtuple4@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.dtuple4 @x9
@x10
@x11
@x12))
(and (HasTypeFuel @u0
@x12
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasTypeFuel @u0
@x8
(ApplyTT (ApplyTT (ApplyTT @x12
@x5)
@x6)
@x7))
(HasTypeFuel @u0
@x11
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasTypeFuel @u0
@x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x11
@x2
@x1))
(HasTypeFuel @u0
@x7
(ApplyTT (ApplyTT @x11
@x5)
@x6))
(HasTypeFuel @u0
@x10
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x10
@x1))
(HasTypeFuel @u0
@x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x10
@x1))
(HasTypeFuel @u0
@x6
(ApplyTT @x10
@x5))
(HasTypeFuel @u0
@x9
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x9))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x9))
(HasTypeFuel @u0
@x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x9))
(HasTypeFuel @u0
@x5
@x9)
(HasTypeFuel @u0
@x1
Tm_type)
(HasTypeFuel @u0
@x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasTypeFuel @u0
@x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasTypeFuel @u0
@x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasTypeFuel @u0
@x5
@x1)
(HasTypeFuel @u0
@x6
(ApplyTT @x2
@x5))
(HasTypeFuel @u0
@x7
(ApplyTT (ApplyTT @x3
@x5)
@x6))
(HasTypeFuel @u0
@x8
(ApplyTT (ApplyTT (ApplyTT @x4
@x5)
@x6)
@x7))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.dtuple4 @x9
@x10
@x11
@x12)))
:qid data_elim_FStar.Pervasives.Mkdtuple4))

:named data_elim_FStar.Pervasives.Mkdtuple4))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.dtuple4 @x9
@x10
@x11
@x12))
(and (Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x5
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x6
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x7
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x8
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Mkdtuple4 @x1
@x2
@x3
@x4
@x5
@x6
@x7
@x8)
(FStar.Pervasives.dtuple4 @x9
@x10
@x11
@x12)))
:qid subterm_ordering_FStar.Pervasives.Mkdtuple4))

:named subterm_ordering_FStar.Pervasives.Mkdtuple4))

; </end encoding FStar.Pervasives.Mkdtuple4>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.dtuple4; Namespace FStar.Pervasives; Name FStar.Pervasives.Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(740,5-740,12)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (HasTypeFuel @u0
@x1
(FStar.Pervasives.dtuple4 @x2
@x3
@x4
@x5))
(and (is-FStar.Pervasives.Mkdtuple4 @x1)
(= @x2
(FStar.Pervasives.Mkdtuple4_a @x1))
(= @x3
(FStar.Pervasives.Mkdtuple4_b @x1))
(= @x4
(FStar.Pervasives.Mkdtuple4_c @x1))
(= @x5
(FStar.Pervasives.Mkdtuple4_d @x1))))
 

:pattern ((HasTypeFuel @u0
@x1
(FStar.Pervasives.dtuple4 @x2
@x3
@x4
@x5)))
:qid fuel_guarded_inversion_FStar.Pervasives.dtuple4))

:named fuel_guarded_inversion_FStar.Pervasives.dtuple4))

; </end encoding >


; <Start encoding FStar.Pervasives.dtuple4__uu___haseq>




;;;;;;;;;;;;;;;;Assumption: dtuple4__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.dtuple4__uu___haseq; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0))
(forall ((@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x4
@x0)
(HasType @x5
(ApplyTT @x1
@x4))
(HasType @x6
(ApplyTT (ApplyTT @x2
@x4)
@x5))
(HasType @x7
(ApplyTT (ApplyTT (ApplyTT @x3
@x4)
@x5)
@x6)))
(and (Valid (Prims.hasEq @x0))
(Valid (Prims.hasEq (ApplyTT @x1
@x4)))
(Valid (Prims.hasEq (ApplyTT (ApplyTT @x2
@x4)
@x5)))
(Valid (Prims.hasEq (ApplyTT (ApplyTT (ApplyTT @x3
@x4)
@x5)
@x6)))))
 
;;no pats
:qid assumption_FStar.Pervasives.dtuple4__uu___haseq.1)))
(Valid (Prims.hasEq (FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3))))
 

:pattern ((Prims.hasEq (FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
:qid assumption_FStar.Pervasives.dtuple4__uu___haseq))
:named assumption_FStar.Pervasives.dtuple4__uu___haseq))

; </end encoding FStar.Pervasives.dtuple4__uu___haseq>


; <Start encoding FStar.Pervasives.uu___is_Mkdtuple4>




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



;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple4 a b c d -> Prims.bool
(declare-fun Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b
Tm_type)
:named kinding_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
:qid FStar.Pervasives_pre_typing_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
:named FStar.Pervasives_pre_typing_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b)
(and (forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
Prims.bool))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b.1))
(IsTotFun @x0)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b.2))
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b.3))
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b.4))
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b.5))))
 

:pattern ((HasTypeZ @x0
Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
:qid FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
:named FStar.Pervasives_interpretation_Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))
(declare-fun FStar.Pervasives.uu___is_Mkdtuple4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Mkdtuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.uu___is_Mkdtuple4 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Mkdtuple4@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.uu___is_Mkdtuple4))

:named token_correspondence_FStar.Pervasives.uu___is_Mkdtuple4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Mkdtuple4@tok
Tm_arrow_76a226dc2cea2ddd4e4258637fc95e5b))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.uu___is_Mkdtuple4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.uu___is_Mkdtuple4 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.uu___is_Mkdtuple4 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.uu___is_Mkdtuple4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Mkdtuple4@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Mkdtuple4))

:named function_token_typing_FStar.Pervasives.uu___is_Mkdtuple4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0))
(HasType @x4
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.uu___is_Mkdtuple4 @x0
@x1
@x2
@x3
@x4)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Mkdtuple4 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.uu___is_Mkdtuple4))

:named typing_FStar.Pervasives.uu___is_Mkdtuple4))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Mkdtuple4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,6-743,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.uu___is_Mkdtuple4 @x0
@x1
@x2
@x3
@x4)
(BoxBool (is-FStar.Pervasives.Mkdtuple4 @x4)))
 

:pattern ((FStar.Pervasives.uu___is_Mkdtuple4 @x0
@x1
@x2
@x3
@x4))
:qid disc_equation_FStar.Pervasives.Mkdtuple4))

:named disc_equation_FStar.Pervasives.Mkdtuple4))

; </end encoding FStar.Pervasives.uu___is_Mkdtuple4>


; <Skipped FStar.Pervasives.uu___is_Mkdtuple4/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple4__item___1>




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



;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple4 a b c d -> a
(declare-fun Tm_arrow_1da4d60ab69f411b912e76cc25e77965 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1da4d60ab69f411b912e76cc25e77965
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_1da4d60ab69f411b912e76cc25e77965
Tm_type)
:named kinding_Tm_arrow_1da4d60ab69f411b912e76cc25e77965))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_1da4d60ab69f411b912e76cc25e77965)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_1da4d60ab69f411b912e76cc25e77965))
:qid FStar.Pervasives_pre_typing_Tm_arrow_1da4d60ab69f411b912e76cc25e77965))

:named FStar.Pervasives_pre_typing_Tm_arrow_1da4d60ab69f411b912e76cc25e77965))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_1da4d60ab69f411b912e76cc25e77965)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x1))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(741,3-741,4)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_1da4d60ab69f411b912e76cc25e77965))
:qid FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965))

:named FStar.Pervasives_interpretation_Tm_arrow_1da4d60ab69f411b912e76cc25e77965))
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___1@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___1@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___1))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___1))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple4__item___1@tok
Tm_arrow_1da4d60ab69f411b912e76cc25e77965))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___1@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___1 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___1.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple4__item___1@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___1))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___1))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0))
(HasType @x4
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4)
@x0))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.__proj__Mkdtuple4__item___1))

:named typing_FStar.Pervasives.__proj__Mkdtuple4__item___1))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___1; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,18-743,20)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Mkdtuple4__1 @x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Mkdtuple4__1))

:named proj_equation_FStar.Pervasives.Mkdtuple4__1))

; </end encoding FStar.Pervasives.__proj__Mkdtuple4__item___1>


; <Skipped FStar.Pervasives.__proj__Mkdtuple4__item___1/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple4__item___2>




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



;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple4 a b c d -> b (Mkdtuple4?._1 projectee)
(declare-fun Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f
Tm_type)
:named kinding_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))
:qid FStar.Pervasives_pre_typing_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))

:named FStar.Pervasives_pre_typing_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
(ApplyTT @x2
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x1
@x2
@x3
@x4
@x5))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,31-743,35)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))
:qid FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))

:named FStar.Pervasives_interpretation_Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___2@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___2@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___2))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___2))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple4__item___2@tok
Tm_arrow_a86867091548f3d7d3ca1cb8b0458b9f))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___2@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.__proj__Mkdtuple4__item___2 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___2 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___2.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple4__item___2@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___2))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___2))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0))
(HasType @x4
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4)
(ApplyTT @x1
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4))))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.__proj__Mkdtuple4__item___2))

:named typing_FStar.Pervasives.__proj__Mkdtuple4__item___2))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___2; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,27-743,29)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Mkdtuple4__2 @x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Mkdtuple4__2))

:named proj_equation_FStar.Pervasives.Mkdtuple4__2))

; </end encoding FStar.Pervasives.__proj__Mkdtuple4__item___2>


; <Skipped FStar.Pervasives.__proj__Mkdtuple4__item___2/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple4__item___3>




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



;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple4 a b c d -> c (Mkdtuple4?._1 projectee) (Mkdtuple4?._2 projectee)
(declare-fun Tm_arrow_ee72552fcc293405aa0e854ba26f27ac () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_ee72552fcc293405aa0e854ba26f27ac
Tm_type)
:named kinding_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ee72552fcc293405aa0e854ba26f27ac)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))
:qid FStar.Pervasives_pre_typing_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))

:named FStar.Pervasives_pre_typing_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ee72552fcc293405aa0e854ba26f27ac)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
(ApplyTT (ApplyTT @x3
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x1
@x2
@x3
@x4
@x5))
(FStar.Pervasives.__proj__Mkdtuple4__item___2 @x1
@x2
@x3
@x4
@x5))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,43-743,50)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))
:qid FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))

:named FStar.Pervasives_interpretation_Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___3@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple4__item___3 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___3@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___3))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___3))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple4__item___3@tok
Tm_arrow_ee72552fcc293405aa0e854ba26f27ac))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___3@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.__proj__Mkdtuple4__item___3 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___3 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___3.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple4__item___3@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___3))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___3))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0))
(HasType @x4
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.__proj__Mkdtuple4__item___3 @x0
@x1
@x2
@x3
@x4)
(ApplyTT (ApplyTT @x2
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4))
(FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4))))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___3 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.__proj__Mkdtuple4__item___3))

:named typing_FStar.Pervasives.__proj__Mkdtuple4__item___3))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___3; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,39-743,41)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple4__item___3 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Mkdtuple4__3 @x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___3 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Mkdtuple4__3))

:named proj_equation_FStar.Pervasives.Mkdtuple4__3))

; </end encoding FStar.Pervasives.__proj__Mkdtuple4__item___3>


; <Skipped FStar.Pervasives.__proj__Mkdtuple4__item___3/>


; <Start encoding FStar.Pervasives.__proj__Mkdtuple4__item___4>




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



;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.dtuple4 a b c d   -> d (Mkdtuple4?._1 projectee) (Mkdtuple4?._2 projectee) (Mkdtuple4?._3 projectee)
(declare-fun Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6
Tm_type)
:named kinding_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))
:qid FStar.Pervasives_pre_typing_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))

:named FStar.Pervasives_pre_typing_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1))
(HasType @x5
(FStar.Pervasives.dtuple4 @x1
@x2
@x3
@x4)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
(ApplyTT (ApplyTT (ApplyTT @x4
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x1
@x2
@x3
@x4
@x5))
(FStar.Pervasives.__proj__Mkdtuple4__item___2 @x1
@x2
@x3
@x4
@x5))
(FStar.Pervasives.__proj__Mkdtuple4__item___3 @x1
@x2
@x3
@x4
@x5))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,58-743,68)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x2
@x1))
(HasType @x4
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x3
@x2
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))
:qid FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))

:named FStar.Pervasives_interpretation_Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))
(declare-fun FStar.Pervasives.__proj__Mkdtuple4__item___4@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.__proj__Mkdtuple4__item___4 @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___4@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___4))

:named token_correspondence_FStar.Pervasives.__proj__Mkdtuple4__item___4))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Mkdtuple4__item___4@tok
Tm_arrow_6c79def96aa5d5d9eb9555c48dd9ebb6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.__proj__Mkdtuple4__item___4@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Pervasives.__proj__Mkdtuple4__item___4 @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___4 @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___4.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Mkdtuple4__item___4@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___4))

:named function_token_typing_FStar.Pervasives.__proj__Mkdtuple4__item___4))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_0b6559e6ff3addf84b0c2880affbb335 @x1
@x0))
(HasType @x3
(Tm_arrow_af8eda99ba3685403be22a88669dcb35 @x2
@x1
@x0))
(HasType @x4
(FStar.Pervasives.dtuple4 @x0
@x1
@x2
@x3)))
(HasType (FStar.Pervasives.__proj__Mkdtuple4__item___4 @x0
@x1
@x2
@x3
@x4)
(ApplyTT (ApplyTT (ApplyTT @x3
(FStar.Pervasives.__proj__Mkdtuple4__item___1 @x0
@x1
@x2
@x3
@x4))
(FStar.Pervasives.__proj__Mkdtuple4__item___2 @x0
@x1
@x2
@x3
@x4))
(FStar.Pervasives.__proj__Mkdtuple4__item___3 @x0
@x1
@x2
@x3
@x4))))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___4 @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Pervasives.__proj__Mkdtuple4__item___4))

:named typing_FStar.Pervasives.__proj__Mkdtuple4__item___4))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Mkdtuple4__item___4; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(743,54-743,56)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (FStar.Pervasives.__proj__Mkdtuple4__item___4 @x0
@x1
@x2
@x3
@x4)
(FStar.Pervasives.Mkdtuple4__4 @x4))
 

:pattern ((FStar.Pervasives.__proj__Mkdtuple4__item___4 @x0
@x1
@x2
@x3
@x4))
:qid proj_equation_FStar.Pervasives.Mkdtuple4__4))

:named proj_equation_FStar.Pervasives.Mkdtuple4__4))

; </end encoding FStar.Pervasives.__proj__Mkdtuple4__item___4>


; <Skipped FStar.Pervasives.__proj__Mkdtuple4__item___4/>


; <Start encoding FStar.Pervasives.ignore>

(declare-fun FStar.Pervasives.ignore (Term Term) Term)
;;;;;;;;;;;;;;;;x: a -> Prims.unit
(declare-fun Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71
Tm_type)
:named kinding_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))
:qid FStar.Pervasives_pre_typing_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))

:named FStar.Pervasives_pre_typing_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
Prims.unit))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,35-746,39)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))
:qid FStar.Pervasives_interpretation_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))

:named FStar.Pervasives_interpretation_Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))
(declare-fun FStar.Pervasives.ignore@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ignore@tok
@x0)
@x1)
(FStar.Pervasives.ignore @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.ignore@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.ignore))

:named token_correspondence_FStar.Pervasives.ignore))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ignore@tok
Tm_arrow_962476a7eea46a6ffc9b658c6d8fbc71))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.ignore@tok
@x1)
@x2)
(FStar.Pervasives.ignore @x1
@x2))
 

:pattern ((FStar.Pervasives.ignore @x1
@x2))
:qid function_token_typing_FStar.Pervasives.ignore.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ignore@tok))
:qid function_token_typing_FStar.Pervasives.ignore))

:named function_token_typing_FStar.Pervasives.ignore))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.ignore @x0
@x1)
Prims.unit))
 

:pattern ((FStar.Pervasives.ignore @x0
@x1))
:qid typing_FStar.Pervasives.ignore))

:named typing_FStar.Pervasives.ignore))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.ignore
;;; Fact-ids: Name FStar.Pervasives.ignore; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(746,4-746,10)
(forall ((@x0 Term) (@x1 Term))
 (! (= (FStar.Pervasives.ignore @x0
@x1)
Tm_unit)
 

:pattern ((FStar.Pervasives.ignore @x0
@x1))
:qid equation_FStar.Pervasives.ignore))

:named equation_FStar.Pervasives.ignore))

; </end encoding FStar.Pervasives.ignore>


; <Start encoding FStar.Pervasives.false_elim>

(declare-fun Tm_refine_f1ecc6ab6882a651504f328937700647 () Term)
;;;;;;;;;;;;;;;;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_interpretation
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,26-754,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,26-754,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))
;;;;;;;;;;;;;;;;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))
(declare-fun FStar.Pervasives.false_elim (Term Term) Term)

;;;;;;;;;;;;;;;;u25880: u25881: Prims.unit{Prims.l_False} -> a
(declare-fun Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2
Tm_type)
:named kinding_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,17-754,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,49-754,50)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))
:qid FStar.Pervasives_pre_typing_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))

:named FStar.Pervasives_pre_typing_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,17-754,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,49-754,50)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,17-754,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,49-754,50)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_refine_f1ecc6ab6882a651504f328937700647))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x1))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,17-754,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,49-754,50)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))
:qid FStar.Pervasives_interpretation_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))

:named FStar.Pervasives_interpretation_Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))
(declare-fun FStar.Pervasives.false_elim@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.false_elim@tok
@x0)
@x1)
(FStar.Pervasives.false_elim @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.false_elim@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.false_elim))

:named token_correspondence_FStar.Pervasives.false_elim))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.false_elim@tok
Tm_arrow_7636fbfab5cd88ba06f60c10ea8caef2))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.false_elim@tok
@x1)
@x2)
(FStar.Pervasives.false_elim @x1
@x2))
 

:pattern ((FStar.Pervasives.false_elim @x1
@x2))
:qid function_token_typing_FStar.Pervasives.false_elim.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.false_elim@tok))
:qid function_token_typing_FStar.Pervasives.false_elim))

:named function_token_typing_FStar.Pervasives.false_elim))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.false_elim; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(754,4-754,14)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_refine_f1ecc6ab6882a651504f328937700647))
(HasType (FStar.Pervasives.false_elim @x0
@x1)
@x0))
 

:pattern ((FStar.Pervasives.false_elim @x0
@x1))
:qid typing_FStar.Pervasives.false_elim))

:named typing_FStar.Pervasives.false_elim))

; </end encoding FStar.Pervasives.false_elim>


; <Start encoding >

;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.__internal_ocaml_attributes () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.PpxDerivingShow () Term)
;;;;;;;;;;;;;;;;data constructor proxy: PpxDerivingShow
(declare-fun FStar.Pervasives.PpxDerivingShow@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.PpxDerivingShowConstant (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.PpxDerivingShowConstant__0 (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: PpxDerivingShowConstant
(declare-fun FStar.Pervasives.PpxDerivingShowConstant@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.PpxDerivingYoJson () Term)
;;;;;;;;;;;;;;;;data constructor proxy: PpxDerivingYoJson
(declare-fun FStar.Pervasives.PpxDerivingYoJson@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CInline () Term)
;;;;;;;;;;;;;;;;data constructor proxy: CInline
(declare-fun FStar.Pervasives.CInline@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Substitute () Term)
;;;;;;;;;;;;;;;;data constructor proxy: Substitute
(declare-fun FStar.Pervasives.Substitute@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Gc () Term)
;;;;;;;;;;;;;;;;data constructor proxy: Gc
(declare-fun FStar.Pervasives.Gc@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.Comment (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.Comment__0 (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: Comment
(declare-fun FStar.Pervasives.Comment@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CPrologue (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.CPrologue__0 (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: CPrologue
(declare-fun FStar.Pervasives.CPrologue@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CEpilogue (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.CEpilogue__0 (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: CEpilogue
(declare-fun FStar.Pervasives.CEpilogue@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CConst (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.CConst__0 (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: CConst
(declare-fun FStar.Pervasives.CConst@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CCConv (Term) Term)
;;;;;;;;;;;;;;;;Projector
(declare-fun FStar.Pervasives.CCConv__0 (Term) Term)
;;;;;;;;;;;;;;;;data constructor proxy: CCConv
(declare-fun FStar.Pervasives.CCConv@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CAbstractStruct () Term)
;;;;;;;;;;;;;;;;data constructor proxy: CAbstractStruct
(declare-fun FStar.Pervasives.CAbstractStruct@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CIfDef () Term)
;;;;;;;;;;;;;;;;data constructor proxy: CIfDef
(declare-fun FStar.Pervasives.CIfDef@tok () Term)
;;;;;;;;;;;;;;;;Constructor
(declare-fun FStar.Pervasives.CMacro () Term)
;;;;;;;;;;;;;;;;data constructor proxy: CMacro
(declare-fun FStar.Pervasives.CMacro@tok () Term)
;;;;;;;;;;;;;;;;_0: Prims.string -> FStar.Pervasives.__internal_ocaml_attributes
(declare-fun Tm_arrow_a25c6dbdd7c43412e925069991c0ef48 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_a25c6dbdd7c43412e925069991c0ef48
Tm_type)
:named kinding_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
:qid FStar.Pervasives_pre_typing_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))

:named FStar.Pervasives_pre_typing_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.string)
(HasType (ApplyTT @x0
@x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
:qid FStar.Pervasives_interpretation_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))

:named FStar.Pervasives_interpretation_Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))






; <Start encoding FStar.Pervasives.__internal_ocaml_attributes>


; <start constructor FStar.Pervasives.__internal_ocaml_attributes>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 674
(Term_constr_id FStar.Pervasives.__internal_ocaml_attributes))
:named constructor_distinct_FStar.Pervasives.__internal_ocaml_attributes))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.__internal_ocaml_attributes ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
674)
(= __@x0
FStar.Pervasives.__internal_ocaml_attributes)))

; </end constructor FStar.Pervasives.__internal_ocaml_attributes>

;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.__internal_ocaml_attributes
Tm_type)
:named kinding_FStar.Pervasives.__internal_ocaml_attributes@tok))
;;;;;;;;;;;;;;;;pretyping
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32)
(forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
FStar.Pervasives.__internal_ocaml_attributes)
(= FStar.Pervasives.__internal_ocaml_attributes
(PreType @x0)))
 

:pattern ((HasTypeFuel @u1
@x0
FStar.Pervasives.__internal_ocaml_attributes))
:qid FStar.Pervasives_pretyping_a4b7a3cd3b1c984348c37abd2aa7744a))

:named FStar.Pervasives_pretyping_a4b7a3cd3b1c984348c37abd2aa7744a))

; </end encoding FStar.Pervasives.__internal_ocaml_attributes>


; <Start encoding FStar.Pervasives.PpxDerivingShow>


; <start constructor FStar.Pervasives.PpxDerivingShow>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 680
(Term_constr_id FStar.Pervasives.PpxDerivingShow))
:named constructor_distinct_FStar.Pervasives.PpxDerivingShow))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.PpxDerivingShow ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
680)
(= __@x0
FStar.Pervasives.PpxDerivingShow)))

; </end constructor FStar.Pervasives.PpxDerivingShow>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.PpxDerivingShow@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.PpxDerivingShow@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.PpxDerivingShow@tok
FStar.Pervasives.PpxDerivingShow)
:named equality_tok_FStar.Pervasives.PpxDerivingShow@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.PpxDerivingShow
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.PpxDerivingShow
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.PpxDerivingShow@tok))

:named data_typing_intro_FStar.Pervasives.PpxDerivingShow@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.PpxDerivingShow))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.PpxDerivingShow))

; </end encoding FStar.Pervasives.PpxDerivingShow>


; <Start encoding FStar.Pervasives.PpxDerivingShowConstant>


; <start constructor FStar.Pervasives.PpxDerivingShowConstant>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (= 682
(Term_constr_id (FStar.Pervasives.PpxDerivingShowConstant @x0)))
 

:pattern ((FStar.Pervasives.PpxDerivingShowConstant @x0))
:qid constructor_distinct_FStar.Pervasives.PpxDerivingShowConstant))

:named constructor_distinct_FStar.Pervasives.PpxDerivingShowConstant))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.PpxDerivingShowConstant__0 (FStar.Pervasives.PpxDerivingShowConstant @x0))
@x0)
 

:pattern ((FStar.Pervasives.PpxDerivingShowConstant @x0))
:qid projection_inverse_FStar.Pervasives.PpxDerivingShowConstant__0))

:named projection_inverse_FStar.Pervasives.PpxDerivingShowConstant__0))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.PpxDerivingShowConstant ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
682)
(= __@x0
(FStar.Pervasives.PpxDerivingShowConstant (FStar.Pervasives.PpxDerivingShowConstant__0 __@x0)))))

; </end constructor FStar.Pervasives.PpxDerivingShowConstant>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 685
(Term_constr_id FStar.Pervasives.PpxDerivingShowConstant@tok))
:named fresh_token_FStar.Pervasives.PpxDerivingShowConstant@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.PpxDerivingShowConstant@tok
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
 

:pattern ((ApplyTT FStar.Pervasives.PpxDerivingShowConstant@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.PpxDerivingShowConstant@tok))
:qid typing_tok_FStar.Pervasives.PpxDerivingShowConstant@tok))

:named typing_tok_FStar.Pervasives.PpxDerivingShowConstant@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.PpxDerivingShowConstant@tok
@x0)
(FStar.Pervasives.PpxDerivingShowConstant @x0))
 

:pattern ((ApplyTT FStar.Pervasives.PpxDerivingShowConstant@tok
@x0))
:qid equality_tok_FStar.Pervasives.PpxDerivingShowConstant@tok))

:named equality_tok_FStar.Pervasives.PpxDerivingShowConstant@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(HasTypeFuel @u0
(FStar.Pervasives.PpxDerivingShowConstant @x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.PpxDerivingShowConstant @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.PpxDerivingShowConstant@tok))

:named data_typing_intro_FStar.Pervasives.PpxDerivingShowConstant@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.PpxDerivingShowConstant @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(HasTypeFuel @u0
@x1
Prims.string))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.PpxDerivingShowConstant @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_elim_FStar.Pervasives.PpxDerivingShowConstant))

:named data_elim_FStar.Pervasives.PpxDerivingShowConstant))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.PpxDerivingShowConstant @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x1
(FStar.Pervasives.PpxDerivingShowConstant @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.PpxDerivingShowConstant @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid subterm_ordering_FStar.Pervasives.PpxDerivingShowConstant))

:named subterm_ordering_FStar.Pervasives.PpxDerivingShowConstant))

; </end encoding FStar.Pervasives.PpxDerivingShowConstant>


; <Start encoding FStar.Pervasives.PpxDerivingYoJson>


; <start constructor FStar.Pervasives.PpxDerivingYoJson>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 687
(Term_constr_id FStar.Pervasives.PpxDerivingYoJson))
:named constructor_distinct_FStar.Pervasives.PpxDerivingYoJson))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.PpxDerivingYoJson ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
687)
(= __@x0
FStar.Pervasives.PpxDerivingYoJson)))

; </end constructor FStar.Pervasives.PpxDerivingYoJson>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.PpxDerivingYoJson@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.PpxDerivingYoJson@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.PpxDerivingYoJson@tok
FStar.Pervasives.PpxDerivingYoJson)
:named equality_tok_FStar.Pervasives.PpxDerivingYoJson@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.PpxDerivingYoJson
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.PpxDerivingYoJson
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.PpxDerivingYoJson@tok))

:named data_typing_intro_FStar.Pervasives.PpxDerivingYoJson@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.PpxDerivingYoJson))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.PpxDerivingYoJson))

; </end encoding FStar.Pervasives.PpxDerivingYoJson>


; <Start encoding FStar.Pervasives.CInline>


; <start constructor FStar.Pervasives.CInline>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 689
(Term_constr_id FStar.Pervasives.CInline))
:named constructor_distinct_FStar.Pervasives.CInline))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CInline ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
689)
(= __@x0
FStar.Pervasives.CInline)))

; </end constructor FStar.Pervasives.CInline>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.CInline@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.CInline@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.CInline@tok
FStar.Pervasives.CInline)
:named equality_tok_FStar.Pervasives.CInline@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.CInline
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.CInline
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CInline@tok))

:named data_typing_intro_FStar.Pervasives.CInline@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.CInline))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.CInline))

; </end encoding FStar.Pervasives.CInline>


; <Start encoding FStar.Pervasives.Substitute>


; <start constructor FStar.Pervasives.Substitute>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 691
(Term_constr_id FStar.Pervasives.Substitute))
:named constructor_distinct_FStar.Pervasives.Substitute))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Substitute ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
691)
(= __@x0
FStar.Pervasives.Substitute)))

; </end constructor FStar.Pervasives.Substitute>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.Substitute@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.Substitute@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.Substitute@tok
FStar.Pervasives.Substitute)
:named equality_tok_FStar.Pervasives.Substitute@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.Substitute
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.Substitute
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.Substitute@tok))

:named data_typing_intro_FStar.Pervasives.Substitute@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.Substitute))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.Substitute))

; </end encoding FStar.Pervasives.Substitute>


; <Start encoding FStar.Pervasives.Gc>


; <start constructor FStar.Pervasives.Gc>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 693
(Term_constr_id FStar.Pervasives.Gc))
:named constructor_distinct_FStar.Pervasives.Gc))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Gc ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
693)
(= __@x0
FStar.Pervasives.Gc)))

; </end constructor FStar.Pervasives.Gc>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.Gc@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.Gc@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.Gc@tok
FStar.Pervasives.Gc)
:named equality_tok_FStar.Pervasives.Gc@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.Gc
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.Gc
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.Gc@tok))

:named data_typing_intro_FStar.Pervasives.Gc@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.Gc))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.Gc))

; </end encoding FStar.Pervasives.Gc>


; <Start encoding FStar.Pervasives.Comment>


; <start constructor FStar.Pervasives.Comment>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (= 695
(Term_constr_id (FStar.Pervasives.Comment @x0)))
 

:pattern ((FStar.Pervasives.Comment @x0))
:qid constructor_distinct_FStar.Pervasives.Comment))

:named constructor_distinct_FStar.Pervasives.Comment))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.Comment__0 (FStar.Pervasives.Comment @x0))
@x0)
 

:pattern ((FStar.Pervasives.Comment @x0))
:qid projection_inverse_FStar.Pervasives.Comment__0))

:named projection_inverse_FStar.Pervasives.Comment__0))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.Comment ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
695)
(= __@x0
(FStar.Pervasives.Comment (FStar.Pervasives.Comment__0 __@x0)))))

; </end constructor FStar.Pervasives.Comment>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 698
(Term_constr_id FStar.Pervasives.Comment@tok))
:named fresh_token_FStar.Pervasives.Comment@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.Comment@tok
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
 

:pattern ((ApplyTT FStar.Pervasives.Comment@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.Comment@tok))
:qid typing_tok_FStar.Pervasives.Comment@tok))

:named typing_tok_FStar.Pervasives.Comment@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.Comment@tok
@x0)
(FStar.Pervasives.Comment @x0))
 

:pattern ((ApplyTT FStar.Pervasives.Comment@tok
@x0))
:qid equality_tok_FStar.Pervasives.Comment@tok))

:named equality_tok_FStar.Pervasives.Comment@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(HasTypeFuel @u0
(FStar.Pervasives.Comment @x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.Comment @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.Comment@tok))

:named data_typing_intro_FStar.Pervasives.Comment@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Comment @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(HasTypeFuel @u0
@x1
Prims.string))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Comment @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_elim_FStar.Pervasives.Comment))

:named data_elim_FStar.Pervasives.Comment))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Comment @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x1
(FStar.Pervasives.Comment @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.Comment @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid subterm_ordering_FStar.Pervasives.Comment))

:named subterm_ordering_FStar.Pervasives.Comment))

; </end encoding FStar.Pervasives.Comment>


; <Start encoding FStar.Pervasives.CPrologue>


; <start constructor FStar.Pervasives.CPrologue>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (= 700
(Term_constr_id (FStar.Pervasives.CPrologue @x0)))
 

:pattern ((FStar.Pervasives.CPrologue @x0))
:qid constructor_distinct_FStar.Pervasives.CPrologue))

:named constructor_distinct_FStar.Pervasives.CPrologue))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.CPrologue__0 (FStar.Pervasives.CPrologue @x0))
@x0)
 

:pattern ((FStar.Pervasives.CPrologue @x0))
:qid projection_inverse_FStar.Pervasives.CPrologue__0))

:named projection_inverse_FStar.Pervasives.CPrologue__0))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CPrologue ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
700)
(= __@x0
(FStar.Pervasives.CPrologue (FStar.Pervasives.CPrologue__0 __@x0)))))

; </end constructor FStar.Pervasives.CPrologue>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 703
(Term_constr_id FStar.Pervasives.CPrologue@tok))
:named fresh_token_FStar.Pervasives.CPrologue@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.CPrologue@tok
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
 

:pattern ((ApplyTT FStar.Pervasives.CPrologue@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.CPrologue@tok))
:qid typing_tok_FStar.Pervasives.CPrologue@tok))

:named typing_tok_FStar.Pervasives.CPrologue@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.CPrologue@tok
@x0)
(FStar.Pervasives.CPrologue @x0))
 

:pattern ((ApplyTT FStar.Pervasives.CPrologue@tok
@x0))
:qid equality_tok_FStar.Pervasives.CPrologue@tok))

:named equality_tok_FStar.Pervasives.CPrologue@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(HasTypeFuel @u0
(FStar.Pervasives.CPrologue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.CPrologue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CPrologue@tok))

:named data_typing_intro_FStar.Pervasives.CPrologue@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CPrologue @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(HasTypeFuel @u0
@x1
Prims.string))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CPrologue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_elim_FStar.Pervasives.CPrologue))

:named data_elim_FStar.Pervasives.CPrologue))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CPrologue @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x1
(FStar.Pervasives.CPrologue @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CPrologue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid subterm_ordering_FStar.Pervasives.CPrologue))

:named subterm_ordering_FStar.Pervasives.CPrologue))

; </end encoding FStar.Pervasives.CPrologue>


; <Start encoding FStar.Pervasives.CEpilogue>


; <start constructor FStar.Pervasives.CEpilogue>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (= 705
(Term_constr_id (FStar.Pervasives.CEpilogue @x0)))
 

:pattern ((FStar.Pervasives.CEpilogue @x0))
:qid constructor_distinct_FStar.Pervasives.CEpilogue))

:named constructor_distinct_FStar.Pervasives.CEpilogue))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.CEpilogue__0 (FStar.Pervasives.CEpilogue @x0))
@x0)
 

:pattern ((FStar.Pervasives.CEpilogue @x0))
:qid projection_inverse_FStar.Pervasives.CEpilogue__0))

:named projection_inverse_FStar.Pervasives.CEpilogue__0))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CEpilogue ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
705)
(= __@x0
(FStar.Pervasives.CEpilogue (FStar.Pervasives.CEpilogue__0 __@x0)))))

; </end constructor FStar.Pervasives.CEpilogue>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 708
(Term_constr_id FStar.Pervasives.CEpilogue@tok))
:named fresh_token_FStar.Pervasives.CEpilogue@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.CEpilogue@tok
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
 

:pattern ((ApplyTT FStar.Pervasives.CEpilogue@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.CEpilogue@tok))
:qid typing_tok_FStar.Pervasives.CEpilogue@tok))

:named typing_tok_FStar.Pervasives.CEpilogue@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.CEpilogue@tok
@x0)
(FStar.Pervasives.CEpilogue @x0))
 

:pattern ((ApplyTT FStar.Pervasives.CEpilogue@tok
@x0))
:qid equality_tok_FStar.Pervasives.CEpilogue@tok))

:named equality_tok_FStar.Pervasives.CEpilogue@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(HasTypeFuel @u0
(FStar.Pervasives.CEpilogue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.CEpilogue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CEpilogue@tok))

:named data_typing_intro_FStar.Pervasives.CEpilogue@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CEpilogue @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(HasTypeFuel @u0
@x1
Prims.string))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CEpilogue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_elim_FStar.Pervasives.CEpilogue))

:named data_elim_FStar.Pervasives.CEpilogue))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CEpilogue @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x1
(FStar.Pervasives.CEpilogue @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CEpilogue @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid subterm_ordering_FStar.Pervasives.CEpilogue))

:named subterm_ordering_FStar.Pervasives.CEpilogue))

; </end encoding FStar.Pervasives.CEpilogue>


; <Start encoding FStar.Pervasives.CConst>


; <start constructor FStar.Pervasives.CConst>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (= 710
(Term_constr_id (FStar.Pervasives.CConst @x0)))
 

:pattern ((FStar.Pervasives.CConst @x0))
:qid constructor_distinct_FStar.Pervasives.CConst))

:named constructor_distinct_FStar.Pervasives.CConst))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.CConst__0 (FStar.Pervasives.CConst @x0))
@x0)
 

:pattern ((FStar.Pervasives.CConst @x0))
:qid projection_inverse_FStar.Pervasives.CConst__0))

:named projection_inverse_FStar.Pervasives.CConst__0))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CConst ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
710)
(= __@x0
(FStar.Pervasives.CConst (FStar.Pervasives.CConst__0 __@x0)))))

; </end constructor FStar.Pervasives.CConst>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 713
(Term_constr_id FStar.Pervasives.CConst@tok))
:named fresh_token_FStar.Pervasives.CConst@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.CConst@tok
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
 

:pattern ((ApplyTT FStar.Pervasives.CConst@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.CConst@tok))
:qid typing_tok_FStar.Pervasives.CConst@tok))

:named typing_tok_FStar.Pervasives.CConst@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.CConst@tok
@x0)
(FStar.Pervasives.CConst @x0))
 

:pattern ((ApplyTT FStar.Pervasives.CConst@tok
@x0))
:qid equality_tok_FStar.Pervasives.CConst@tok))

:named equality_tok_FStar.Pervasives.CConst@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(HasTypeFuel @u0
(FStar.Pervasives.CConst @x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.CConst @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CConst@tok))

:named data_typing_intro_FStar.Pervasives.CConst@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CConst @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(HasTypeFuel @u0
@x1
Prims.string))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CConst @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_elim_FStar.Pervasives.CConst))

:named data_elim_FStar.Pervasives.CConst))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CConst @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x1
(FStar.Pervasives.CConst @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CConst @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid subterm_ordering_FStar.Pervasives.CConst))

:named subterm_ordering_FStar.Pervasives.CConst))

; </end encoding FStar.Pervasives.CConst>


; <Start encoding FStar.Pervasives.CCConv>


; <start constructor FStar.Pervasives.CCConv>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (= 715
(Term_constr_id (FStar.Pervasives.CCConv @x0)))
 

:pattern ((FStar.Pervasives.CCConv @x0))
:qid constructor_distinct_FStar.Pervasives.CCConv))

:named constructor_distinct_FStar.Pervasives.CCConv))
;;;;;;;;;;;;;;;;Projection inverse
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.CCConv__0 (FStar.Pervasives.CCConv @x0))
@x0)
 

:pattern ((FStar.Pervasives.CCConv @x0))
:qid projection_inverse_FStar.Pervasives.CCConv__0))

:named projection_inverse_FStar.Pervasives.CCConv__0))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CCConv ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
715)
(= __@x0
(FStar.Pervasives.CCConv (FStar.Pervasives.CCConv__0 __@x0)))))

; </end constructor FStar.Pervasives.CCConv>

;;;;;;;;;;;;;;;;fresh token
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 718
(Term_constr_id FStar.Pervasives.CCConv@tok))
:named fresh_token_FStar.Pervasives.CCConv@tok))
;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (NoHoist @x0
(HasType FStar.Pervasives.CCConv@tok
Tm_arrow_a25c6dbdd7c43412e925069991c0ef48))
 

:pattern ((ApplyTT FStar.Pervasives.CCConv@tok
@x0))

:pattern ((ApplyTT @x0
FStar.Pervasives.CCConv@tok))
:qid typing_tok_FStar.Pervasives.CCConv@tok))

:named typing_tok_FStar.Pervasives.CCConv@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.CCConv@tok
@x0)
(FStar.Pervasives.CCConv @x0))
 

:pattern ((ApplyTT FStar.Pervasives.CCConv@tok
@x0))
:qid equality_tok_FStar.Pervasives.CCConv@tok))

:named equality_tok_FStar.Pervasives.CCConv@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Prims.string)
(HasTypeFuel @u0
(FStar.Pervasives.CCConv @x1)
FStar.Pervasives.__internal_ocaml_attributes))
 

:pattern ((HasTypeFuel @u0
(FStar.Pervasives.CCConv @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CCConv@tok))

:named data_typing_intro_FStar.Pervasives.CCConv@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CCConv @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(HasTypeFuel @u0
@x1
Prims.string))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CCConv @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_elim_FStar.Pervasives.CCConv))

:named data_elim_FStar.Pervasives.CCConv))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CCConv @x1)
FStar.Pervasives.__internal_ocaml_attributes)
(Valid (Prims.precedes Prims.lex_t
Prims.lex_t
@x1
(FStar.Pervasives.CCConv @x1))))
 

:pattern ((HasTypeFuel (SFuel @u0)
(FStar.Pervasives.CCConv @x1)
FStar.Pervasives.__internal_ocaml_attributes))
:qid subterm_ordering_FStar.Pervasives.CCConv))

:named subterm_ordering_FStar.Pervasives.CCConv))

; </end encoding FStar.Pervasives.CCConv>


; <Start encoding FStar.Pervasives.CAbstractStruct>


; <start constructor FStar.Pervasives.CAbstractStruct>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 720
(Term_constr_id FStar.Pervasives.CAbstractStruct))
:named constructor_distinct_FStar.Pervasives.CAbstractStruct))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CAbstractStruct ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
720)
(= __@x0
FStar.Pervasives.CAbstractStruct)))

; </end constructor FStar.Pervasives.CAbstractStruct>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.CAbstractStruct@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.CAbstractStruct@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.CAbstractStruct@tok
FStar.Pervasives.CAbstractStruct)
:named equality_tok_FStar.Pervasives.CAbstractStruct@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.CAbstractStruct
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.CAbstractStruct
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CAbstractStruct@tok))

:named data_typing_intro_FStar.Pervasives.CAbstractStruct@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.CAbstractStruct))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.CAbstractStruct))

; </end encoding FStar.Pervasives.CAbstractStruct>


; <Start encoding FStar.Pervasives.CIfDef>


; <start constructor FStar.Pervasives.CIfDef>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 722
(Term_constr_id FStar.Pervasives.CIfDef))
:named constructor_distinct_FStar.Pervasives.CIfDef))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CIfDef ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
722)
(= __@x0
FStar.Pervasives.CIfDef)))

; </end constructor FStar.Pervasives.CIfDef>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.CIfDef@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.CIfDef@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.CIfDef@tok
FStar.Pervasives.CIfDef)
:named equality_tok_FStar.Pervasives.CIfDef@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.CIfDef
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.CIfDef
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CIfDef@tok))

:named data_typing_intro_FStar.Pervasives.CIfDef@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.CIfDef))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.CIfDef))

; </end encoding FStar.Pervasives.CIfDef>


; <Start encoding FStar.Pervasives.CMacro>


; <start constructor FStar.Pervasives.CMacro>

;;;;;;;;;;;;;;;;Constructor distinct
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= 724
(Term_constr_id FStar.Pervasives.CMacro))
:named constructor_distinct_FStar.Pervasives.CMacro))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-FStar.Pervasives.CMacro ((__@x0 Term)) Bool
 (and (= (Term_constr_id __@x0)
724)
(= __@x0
FStar.Pervasives.CMacro)))

; </end constructor FStar.Pervasives.CMacro>

;;;;;;;;;;;;;;;;typing for data constructor proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (HasType FStar.Pervasives.CMacro@tok
FStar.Pervasives.__internal_ocaml_attributes)
:named typing_tok_FStar.Pervasives.CMacro@tok))
;;;;;;;;;;;;;;;;equality for proxy
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! (= FStar.Pervasives.CMacro@tok
FStar.Pervasives.CMacro)
:named equality_tok_FStar.Pervasives.CMacro@tok))
;;;;;;;;;;;;;;;;data constructor typing intro
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10)
(forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
FStar.Pervasives.CMacro
FStar.Pervasives.__internal_ocaml_attributes)
 

:pattern ((HasTypeFuel @u0
FStar.Pervasives.CMacro
FStar.Pervasives.__internal_ocaml_attributes))
:qid data_typing_intro_FStar.Pervasives.CMacro@tok))

:named data_typing_intro_FStar.Pervasives.CMacro@tok))
;;;;;;;;;;;;;;;;data constructor typing elim
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named data_elim_FStar.Pervasives.CMacro))
;;;;;;;;;;;;;;;;subterm ordering
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! true
:named subterm_ordering_FStar.Pervasives.CMacro))

; </end encoding FStar.Pervasives.CMacro>

;;;;;;;;;;;;;;;;inversion axiom
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShow; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingShowConstant; Namespace FStar.Pervasives; Name FStar.Pervasives.PpxDerivingYoJson; Namespace FStar.Pervasives; Name FStar.Pervasives.CInline; Namespace FStar.Pervasives; Name FStar.Pervasives.Substitute; Namespace FStar.Pervasives; Name FStar.Pervasives.Gc; Namespace FStar.Pervasives; Name FStar.Pervasives.Comment; Namespace FStar.Pervasives; Name FStar.Pervasives.CPrologue; Namespace FStar.Pervasives; Name FStar.Pervasives.CEpilogue; Namespace FStar.Pervasives; Name FStar.Pervasives.CConst; Namespace FStar.Pervasives; Name FStar.Pervasives.CCConv; Namespace FStar.Pervasives; Name FStar.Pervasives.CAbstractStruct; Namespace FStar.Pervasives; Name FStar.Pervasives.CIfDef; Namespace FStar.Pervasives; Name FStar.Pervasives.CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(781,5-781,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
FStar.Pervasives.__internal_ocaml_attributes)
(or (is-FStar.Pervasives.PpxDerivingShow @x1)
(is-FStar.Pervasives.PpxDerivingShowConstant @x1)
(is-FStar.Pervasives.PpxDerivingYoJson @x1)
(is-FStar.Pervasives.CInline @x1)
(is-FStar.Pervasives.Substitute @x1)
(is-FStar.Pervasives.Gc @x1)
(is-FStar.Pervasives.Comment @x1)
(is-FStar.Pervasives.CPrologue @x1)
(is-FStar.Pervasives.CEpilogue @x1)
(is-FStar.Pervasives.CConst @x1)
(is-FStar.Pervasives.CCConv @x1)
(is-FStar.Pervasives.CAbstractStruct @x1)
(is-FStar.Pervasives.CIfDef @x1)
(is-FStar.Pervasives.CMacro @x1)))
 

:pattern ((HasTypeFuel (SFuel @u0)
@x1
FStar.Pervasives.__internal_ocaml_attributes))
:qid fuel_guarded_inversion_FStar.Pervasives.__internal_ocaml_attributes))

:named fuel_guarded_inversion_FStar.Pervasives.__internal_ocaml_attributes))

; </end encoding >


; <Start encoding FStar.Pervasives.__internal_ocaml_attributes__uu___haseq>

;;;;;;;;;;;;;;;;Assumption: __internal_ocaml_attributes__uu___haseq
;;; Fact-ids: Name FStar.Pervasives.__internal_ocaml_attributes__uu___haseq; Namespace FStar.Pervasives
(assert (! (Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes))
:named assumption_FStar.Pervasives.__internal_ocaml_attributes__uu___haseq))

; </end encoding FStar.Pervasives.__internal_ocaml_attributes__uu___haseq>


; <Start encoding FStar.Pervasives.uu___is_PpxDerivingShow>

(declare-fun FStar.Pervasives.uu___is_PpxDerivingShow (Term) Term)
;;;;;;;;;;;;;;;;projectee: FStar.Pervasives.__internal_ocaml_attributes -> Prims.bool
(declare-fun Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41
Tm_type)
:named kinding_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
:qid FStar.Pervasives_pre_typing_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
:named FStar.Pervasives_pre_typing_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41)
(and (forall ((@x1 Term))
 (! (implies (HasType @x1
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (ApplyTT @x0
@x1)
Prims.bool))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41.1))
(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
:qid FStar.Pervasives_interpretation_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
:named FStar.Pervasives_interpretation_Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))
(declare-fun FStar.Pervasives.uu___is_PpxDerivingShow@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_PpxDerivingShow@tok
@x0)
(FStar.Pervasives.uu___is_PpxDerivingShow @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_PpxDerivingShow@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_PpxDerivingShow))

:named token_correspondence_FStar.Pervasives.uu___is_PpxDerivingShow))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_PpxDerivingShow@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_PpxDerivingShow@tok
@x1)
(FStar.Pervasives.uu___is_PpxDerivingShow @x1))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingShow @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_PpxDerivingShow.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_PpxDerivingShow@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_PpxDerivingShow))

:named function_token_typing_FStar.Pervasives.uu___is_PpxDerivingShow))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_PpxDerivingShow @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingShow @x0))
:qid typing_FStar.Pervasives.uu___is_PpxDerivingShow))

:named typing_FStar.Pervasives.uu___is_PpxDerivingShow))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShow; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(782,4-782,19)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_PpxDerivingShow @x0)
(BoxBool (is-FStar.Pervasives.PpxDerivingShow @x0)))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingShow @x0))
:qid disc_equation_FStar.Pervasives.PpxDerivingShow))

:named disc_equation_FStar.Pervasives.PpxDerivingShow))

; </end encoding FStar.Pervasives.uu___is_PpxDerivingShow>


; <Skipped FStar.Pervasives.uu___is_PpxDerivingShow/>


; <Start encoding FStar.Pervasives.uu___is_PpxDerivingShowConstant>

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

(declare-fun FStar.Pervasives.uu___is_PpxDerivingShowConstant@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShowConstant; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_PpxDerivingShowConstant@tok
@x0)
(FStar.Pervasives.uu___is_PpxDerivingShowConstant @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_PpxDerivingShowConstant@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_PpxDerivingShowConstant))

:named token_correspondence_FStar.Pervasives.uu___is_PpxDerivingShowConstant))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShowConstant; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_PpxDerivingShowConstant@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_PpxDerivingShowConstant@tok
@x1)
(FStar.Pervasives.uu___is_PpxDerivingShowConstant @x1))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingShowConstant @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_PpxDerivingShowConstant.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_PpxDerivingShowConstant@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_PpxDerivingShowConstant))

:named function_token_typing_FStar.Pervasives.uu___is_PpxDerivingShowConstant))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShowConstant; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_PpxDerivingShowConstant @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingShowConstant @x0))
:qid typing_FStar.Pervasives.uu___is_PpxDerivingShowConstant))

:named typing_FStar.Pervasives.uu___is_PpxDerivingShowConstant))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingShowConstant; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_PpxDerivingShowConstant @x0)
(BoxBool (is-FStar.Pervasives.PpxDerivingShowConstant @x0)))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingShowConstant @x0))
:qid disc_equation_FStar.Pervasives.PpxDerivingShowConstant))

:named disc_equation_FStar.Pervasives.PpxDerivingShowConstant))

; </end encoding FStar.Pervasives.uu___is_PpxDerivingShowConstant>


; <Skipped FStar.Pervasives.uu___is_PpxDerivingShowConstant/>


; <Start encoding FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0>

(declare-fun Tm_refine_564db2f0aa0878b4d96c60508be3dd36 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_refine_564db2f0aa0878b4d96c60508be3dd36
Tm_type)
:named refinement_kinding_Tm_refine_564db2f0aa0878b4d96c60508be3dd36))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_564db2f0aa0878b4d96c60508be3dd36)
(and (HasTypeFuel @u0
@x1
FStar.Pervasives.__internal_ocaml_attributes)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,4-783,27)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_PpxDerivingShowConstant @x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_564db2f0aa0878b4d96c60508be3dd36))
:qid refinement_interpretation_Tm_refine_564db2f0aa0878b4d96c60508be3dd36))

:named refinement_interpretation_Tm_refine_564db2f0aa0878b4d96c60508be3dd36))
;;;;;;;;;;;;;;;;haseq for Tm_refine_564db2f0aa0878b4d96c60508be3dd36
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (iff (Valid (Prims.hasEq Tm_refine_564db2f0aa0878b4d96c60508be3dd36))
(Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes)))
:named haseqTm_refine_564db2f0aa0878b4d96c60508be3dd36))
(declare-fun FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 (Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.__internal_ocaml_attributes {PpxDerivingShowConstant? _}   -> Prims.string
(declare-fun Tm_arrow_dbb84ef8131159481071b6d6a41b7f31 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_dbb84ef8131159481071b6d6a41b7f31
Tm_type)
:named kinding_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,31-783,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,31-783,37)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_dbb84ef8131159481071b6d6a41b7f31)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))
:qid FStar.Pervasives_pre_typing_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))

:named FStar.Pervasives_pre_typing_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,31-783,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,31-783,37)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_dbb84ef8131159481071b6d6a41b7f31)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,31-783,37); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(783,31-783,37)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_refine_564db2f0aa0878b4d96c60508be3dd36)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))
:qid FStar.Pervasives_interpretation_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))

:named FStar.Pervasives_interpretation_Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))
(declare-fun FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0@tok
@x0)
(FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x0))
 

:pattern ((ApplyTT FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0@tok
@x0))
:qid token_correspondence_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0))
:named token_correspondence_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0@tok
Tm_arrow_dbb84ef8131159481071b6d6a41b7f31))
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0@tok
@x1)
(FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x1))
 

:pattern ((FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x1))
:qid function_token_typing_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0.1)))
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0@tok))
:qid function_token_typing_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0))
:named function_token_typing_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_refine_564db2f0aa0878b4d96c60508be3dd36)
(HasType (FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x0)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x0))
:qid typing_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0))
:named typing_FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x0)
(FStar.Pervasives.PpxDerivingShowConstant__0 @x0))
 

:pattern ((FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0 @x0))
:qid proj_equation_FStar.Pervasives.PpxDerivingShowConstant__0))
:named proj_equation_FStar.Pervasives.PpxDerivingShowConstant__0))

; </end encoding FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0>


; <Skipped FStar.Pervasives.__proj__PpxDerivingShowConstant__item___0/>


; <Start encoding FStar.Pervasives.uu___is_PpxDerivingYoJson>

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

(declare-fun FStar.Pervasives.uu___is_PpxDerivingYoJson@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingYoJson; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_PpxDerivingYoJson@tok
@x0)
(FStar.Pervasives.uu___is_PpxDerivingYoJson @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_PpxDerivingYoJson@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_PpxDerivingYoJson))

:named token_correspondence_FStar.Pervasives.uu___is_PpxDerivingYoJson))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingYoJson; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_PpxDerivingYoJson@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_PpxDerivingYoJson@tok
@x1)
(FStar.Pervasives.uu___is_PpxDerivingYoJson @x1))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingYoJson @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_PpxDerivingYoJson.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_PpxDerivingYoJson@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_PpxDerivingYoJson))

:named function_token_typing_FStar.Pervasives.uu___is_PpxDerivingYoJson))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingYoJson; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_PpxDerivingYoJson @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingYoJson @x0))
:qid typing_FStar.Pervasives.uu___is_PpxDerivingYoJson))

:named typing_FStar.Pervasives.uu___is_PpxDerivingYoJson))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_PpxDerivingYoJson; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(784,4-784,21)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_PpxDerivingYoJson @x0)
(BoxBool (is-FStar.Pervasives.PpxDerivingYoJson @x0)))
 

:pattern ((FStar.Pervasives.uu___is_PpxDerivingYoJson @x0))
:qid disc_equation_FStar.Pervasives.PpxDerivingYoJson))

:named disc_equation_FStar.Pervasives.PpxDerivingYoJson))

; </end encoding FStar.Pervasives.uu___is_PpxDerivingYoJson>


; <Skipped FStar.Pervasives.uu___is_PpxDerivingYoJson/>


; <Start encoding FStar.Pervasives.uu___is_CInline>

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

(declare-fun FStar.Pervasives.uu___is_CInline@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CInline; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CInline@tok
@x0)
(FStar.Pervasives.uu___is_CInline @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CInline@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CInline))

:named token_correspondence_FStar.Pervasives.uu___is_CInline))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CInline; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CInline@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CInline@tok
@x1)
(FStar.Pervasives.uu___is_CInline @x1))
 

:pattern ((FStar.Pervasives.uu___is_CInline @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CInline.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CInline@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CInline))

:named function_token_typing_FStar.Pervasives.uu___is_CInline))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CInline; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CInline @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CInline @x0))
:qid typing_FStar.Pervasives.uu___is_CInline))

:named typing_FStar.Pervasives.uu___is_CInline))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CInline; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(785,4-785,11)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CInline @x0)
(BoxBool (is-FStar.Pervasives.CInline @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CInline @x0))
:qid disc_equation_FStar.Pervasives.CInline))

:named disc_equation_FStar.Pervasives.CInline))

; </end encoding FStar.Pervasives.uu___is_CInline>


; <Skipped FStar.Pervasives.uu___is_CInline/>


; <Start encoding FStar.Pervasives.uu___is_Substitute>

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

(declare-fun FStar.Pervasives.uu___is_Substitute@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Substitute; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_Substitute@tok
@x0)
(FStar.Pervasives.uu___is_Substitute @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_Substitute@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_Substitute))

:named token_correspondence_FStar.Pervasives.uu___is_Substitute))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Substitute; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Substitute@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_Substitute@tok
@x1)
(FStar.Pervasives.uu___is_Substitute @x1))
 

:pattern ((FStar.Pervasives.uu___is_Substitute @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_Substitute.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Substitute@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Substitute))

:named function_token_typing_FStar.Pervasives.uu___is_Substitute))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Substitute; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_Substitute @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Substitute @x0))
:qid typing_FStar.Pervasives.uu___is_Substitute))

:named typing_FStar.Pervasives.uu___is_Substitute))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Substitute; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(788,4-788,14)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_Substitute @x0)
(BoxBool (is-FStar.Pervasives.Substitute @x0)))
 

:pattern ((FStar.Pervasives.uu___is_Substitute @x0))
:qid disc_equation_FStar.Pervasives.Substitute))

:named disc_equation_FStar.Pervasives.Substitute))

; </end encoding FStar.Pervasives.uu___is_Substitute>


; <Skipped FStar.Pervasives.uu___is_Substitute/>


; <Start encoding FStar.Pervasives.uu___is_Gc>

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

(declare-fun FStar.Pervasives.uu___is_Gc@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Gc; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_Gc@tok
@x0)
(FStar.Pervasives.uu___is_Gc @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_Gc@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_Gc))

:named token_correspondence_FStar.Pervasives.uu___is_Gc))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Gc; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Gc@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_Gc@tok
@x1)
(FStar.Pervasives.uu___is_Gc @x1))
 

:pattern ((FStar.Pervasives.uu___is_Gc @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_Gc.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Gc@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Gc))

:named function_token_typing_FStar.Pervasives.uu___is_Gc))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Gc; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_Gc @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Gc @x0))
:qid typing_FStar.Pervasives.uu___is_Gc))

:named typing_FStar.Pervasives.uu___is_Gc))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Gc; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(792,4-792,6)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_Gc @x0)
(BoxBool (is-FStar.Pervasives.Gc @x0)))
 

:pattern ((FStar.Pervasives.uu___is_Gc @x0))
:qid disc_equation_FStar.Pervasives.Gc))

:named disc_equation_FStar.Pervasives.Gc))

; </end encoding FStar.Pervasives.uu___is_Gc>


; <Skipped FStar.Pervasives.uu___is_Gc/>


; <Start encoding FStar.Pervasives.uu___is_Comment>

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

(declare-fun FStar.Pervasives.uu___is_Comment@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_Comment; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_Comment@tok
@x0)
(FStar.Pervasives.uu___is_Comment @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_Comment@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_Comment))

:named token_correspondence_FStar.Pervasives.uu___is_Comment))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Comment; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_Comment@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_Comment@tok
@x1)
(FStar.Pervasives.uu___is_Comment @x1))
 

:pattern ((FStar.Pervasives.uu___is_Comment @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_Comment.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_Comment@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_Comment))

:named function_token_typing_FStar.Pervasives.uu___is_Comment))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_Comment; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_Comment @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_Comment @x0))
:qid typing_FStar.Pervasives.uu___is_Comment))

:named typing_FStar.Pervasives.uu___is_Comment))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_Comment; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_Comment @x0)
(BoxBool (is-FStar.Pervasives.Comment @x0)))
 

:pattern ((FStar.Pervasives.uu___is_Comment @x0))
:qid disc_equation_FStar.Pervasives.Comment))

:named disc_equation_FStar.Pervasives.Comment))

; </end encoding FStar.Pervasives.uu___is_Comment>


; <Skipped FStar.Pervasives.uu___is_Comment/>


; <Start encoding FStar.Pervasives.__proj__Comment__item___0>

(declare-fun Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0
Tm_type)
:named refinement_kinding_Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0)
(and (HasTypeFuel @u0
@x1
FStar.Pervasives.__internal_ocaml_attributes)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,4-796,11)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_Comment @x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0))
:qid refinement_interpretation_Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0))

:named refinement_interpretation_Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0))
;;;;;;;;;;;;;;;;haseq for Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (iff (Valid (Prims.hasEq Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0))
(Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes)))
:named haseqTm_refine_c53089e2d20d1b0f5a267296ac8e45f0))
(declare-fun FStar.Pervasives.__proj__Comment__item___0 (Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.__internal_ocaml_attributes {Comment? _} -> Prims.string
(declare-fun Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2
Tm_type)
:named kinding_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,15-796,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,15-796,21)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))
:qid FStar.Pervasives_pre_typing_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))

:named FStar.Pervasives_pre_typing_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,15-796,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,15-796,21)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,15-796,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(796,15-796,21)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))
:qid FStar.Pervasives_interpretation_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))

:named FStar.Pervasives_interpretation_Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))
(declare-fun FStar.Pervasives.__proj__Comment__item___0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__Comment__item___0@tok
@x0)
(FStar.Pervasives.__proj__Comment__item___0 @x0))
 

:pattern ((ApplyTT FStar.Pervasives.__proj__Comment__item___0@tok
@x0))
:qid token_correspondence_FStar.Pervasives.__proj__Comment__item___0))
:named token_correspondence_FStar.Pervasives.__proj__Comment__item___0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__Comment__item___0@tok
Tm_arrow_d4c2bbf4fb852b3f4b9961c7cbc2f3a2))
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__Comment__item___0@tok
@x1)
(FStar.Pervasives.__proj__Comment__item___0 @x1))
 

:pattern ((FStar.Pervasives.__proj__Comment__item___0 @x1))
:qid function_token_typing_FStar.Pervasives.__proj__Comment__item___0.1)))
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__Comment__item___0@tok))
:qid function_token_typing_FStar.Pervasives.__proj__Comment__item___0))
:named function_token_typing_FStar.Pervasives.__proj__Comment__item___0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_refine_c53089e2d20d1b0f5a267296ac8e45f0)
(HasType (FStar.Pervasives.__proj__Comment__item___0 @x0)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__Comment__item___0 @x0))
:qid typing_FStar.Pervasives.__proj__Comment__item___0))
:named typing_FStar.Pervasives.__proj__Comment__item___0))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__Comment__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (FStar.Pervasives.__proj__Comment__item___0 @x0)
(FStar.Pervasives.Comment__0 @x0))
 

:pattern ((FStar.Pervasives.__proj__Comment__item___0 @x0))
:qid proj_equation_FStar.Pervasives.Comment__0))
:named proj_equation_FStar.Pervasives.Comment__0))

; </end encoding FStar.Pervasives.__proj__Comment__item___0>


; <Skipped FStar.Pervasives.__proj__Comment__item___0/>


; <Start encoding FStar.Pervasives.uu___is_CPrologue>

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

(declare-fun FStar.Pervasives.uu___is_CPrologue@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CPrologue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CPrologue@tok
@x0)
(FStar.Pervasives.uu___is_CPrologue @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CPrologue@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CPrologue))

:named token_correspondence_FStar.Pervasives.uu___is_CPrologue))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CPrologue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CPrologue@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CPrologue@tok
@x1)
(FStar.Pervasives.uu___is_CPrologue @x1))
 

:pattern ((FStar.Pervasives.uu___is_CPrologue @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CPrologue.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CPrologue@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CPrologue))

:named function_token_typing_FStar.Pervasives.uu___is_CPrologue))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CPrologue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CPrologue @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CPrologue @x0))
:qid typing_FStar.Pervasives.uu___is_CPrologue))

:named typing_FStar.Pervasives.uu___is_CPrologue))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CPrologue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CPrologue @x0)
(BoxBool (is-FStar.Pervasives.CPrologue @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CPrologue @x0))
:qid disc_equation_FStar.Pervasives.CPrologue))

:named disc_equation_FStar.Pervasives.CPrologue))

; </end encoding FStar.Pervasives.uu___is_CPrologue>


; <Skipped FStar.Pervasives.uu___is_CPrologue/>


; <Start encoding FStar.Pervasives.__proj__CPrologue__item___0>

(declare-fun Tm_refine_ac46c1a2a06ce46a180e0eda48004c47 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_refine_ac46c1a2a06ce46a180e0eda48004c47
Tm_type)
:named refinement_kinding_Tm_refine_ac46c1a2a06ce46a180e0eda48004c47))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_ac46c1a2a06ce46a180e0eda48004c47)
(and (HasTypeFuel @u0
@x1
FStar.Pervasives.__internal_ocaml_attributes)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,4-799,13)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_CPrologue @x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_ac46c1a2a06ce46a180e0eda48004c47))
:qid refinement_interpretation_Tm_refine_ac46c1a2a06ce46a180e0eda48004c47))

:named refinement_interpretation_Tm_refine_ac46c1a2a06ce46a180e0eda48004c47))
;;;;;;;;;;;;;;;;haseq for Tm_refine_ac46c1a2a06ce46a180e0eda48004c47
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (iff (Valid (Prims.hasEq Tm_refine_ac46c1a2a06ce46a180e0eda48004c47))
(Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes)))
:named haseqTm_refine_ac46c1a2a06ce46a180e0eda48004c47))
(declare-fun FStar.Pervasives.__proj__CPrologue__item___0 (Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.__internal_ocaml_attributes {CPrologue? _} -> Prims.string
(declare-fun Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf
Tm_type)
:named kinding_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,17-799,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,17-799,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))
:qid FStar.Pervasives_pre_typing_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))

:named FStar.Pervasives_pre_typing_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,17-799,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,17-799,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,17-799,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(799,17-799,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_refine_ac46c1a2a06ce46a180e0eda48004c47)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))
:qid FStar.Pervasives_interpretation_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))

:named FStar.Pervasives_interpretation_Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))
(declare-fun FStar.Pervasives.__proj__CPrologue__item___0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CPrologue__item___0@tok
@x0)
(FStar.Pervasives.__proj__CPrologue__item___0 @x0))
 

:pattern ((ApplyTT FStar.Pervasives.__proj__CPrologue__item___0@tok
@x0))
:qid token_correspondence_FStar.Pervasives.__proj__CPrologue__item___0))
:named token_correspondence_FStar.Pervasives.__proj__CPrologue__item___0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__CPrologue__item___0@tok
Tm_arrow_929b9daa0a2a2e99e3571b146c52feaf))
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CPrologue__item___0@tok
@x1)
(FStar.Pervasives.__proj__CPrologue__item___0 @x1))
 

:pattern ((FStar.Pervasives.__proj__CPrologue__item___0 @x1))
:qid function_token_typing_FStar.Pervasives.__proj__CPrologue__item___0.1)))
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__CPrologue__item___0@tok))
:qid function_token_typing_FStar.Pervasives.__proj__CPrologue__item___0))
:named function_token_typing_FStar.Pervasives.__proj__CPrologue__item___0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_refine_ac46c1a2a06ce46a180e0eda48004c47)
(HasType (FStar.Pervasives.__proj__CPrologue__item___0 @x0)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__CPrologue__item___0 @x0))
:qid typing_FStar.Pervasives.__proj__CPrologue__item___0))
:named typing_FStar.Pervasives.__proj__CPrologue__item___0))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__CPrologue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (FStar.Pervasives.__proj__CPrologue__item___0 @x0)
(FStar.Pervasives.CPrologue__0 @x0))
 

:pattern ((FStar.Pervasives.__proj__CPrologue__item___0 @x0))
:qid proj_equation_FStar.Pervasives.CPrologue__0))
:named proj_equation_FStar.Pervasives.CPrologue__0))

; </end encoding FStar.Pervasives.__proj__CPrologue__item___0>


; <Skipped FStar.Pervasives.__proj__CPrologue__item___0/>


; <Start encoding FStar.Pervasives.uu___is_CEpilogue>

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

(declare-fun FStar.Pervasives.uu___is_CEpilogue@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CEpilogue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CEpilogue@tok
@x0)
(FStar.Pervasives.uu___is_CEpilogue @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CEpilogue@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CEpilogue))

:named token_correspondence_FStar.Pervasives.uu___is_CEpilogue))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CEpilogue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CEpilogue@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CEpilogue@tok
@x1)
(FStar.Pervasives.uu___is_CEpilogue @x1))
 

:pattern ((FStar.Pervasives.uu___is_CEpilogue @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CEpilogue.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CEpilogue@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CEpilogue))

:named function_token_typing_FStar.Pervasives.uu___is_CEpilogue))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CEpilogue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CEpilogue @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CEpilogue @x0))
:qid typing_FStar.Pervasives.uu___is_CEpilogue))

:named typing_FStar.Pervasives.uu___is_CEpilogue))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CEpilogue; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CEpilogue @x0)
(BoxBool (is-FStar.Pervasives.CEpilogue @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CEpilogue @x0))
:qid disc_equation_FStar.Pervasives.CEpilogue))

:named disc_equation_FStar.Pervasives.CEpilogue))

; </end encoding FStar.Pervasives.uu___is_CEpilogue>


; <Skipped FStar.Pervasives.uu___is_CEpilogue/>


; <Start encoding FStar.Pervasives.__proj__CEpilogue__item___0>

(declare-fun Tm_refine_47384bef739d1f0729fd782d351dc9a5 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_refine_47384bef739d1f0729fd782d351dc9a5
Tm_type)
:named refinement_kinding_Tm_refine_47384bef739d1f0729fd782d351dc9a5))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_47384bef739d1f0729fd782d351dc9a5)
(and (HasTypeFuel @u0
@x1
FStar.Pervasives.__internal_ocaml_attributes)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,4-802,13)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_CEpilogue @x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_47384bef739d1f0729fd782d351dc9a5))
:qid refinement_interpretation_Tm_refine_47384bef739d1f0729fd782d351dc9a5))

:named refinement_interpretation_Tm_refine_47384bef739d1f0729fd782d351dc9a5))
;;;;;;;;;;;;;;;;haseq for Tm_refine_47384bef739d1f0729fd782d351dc9a5
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (iff (Valid (Prims.hasEq Tm_refine_47384bef739d1f0729fd782d351dc9a5))
(Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes)))
:named haseqTm_refine_47384bef739d1f0729fd782d351dc9a5))
(declare-fun FStar.Pervasives.__proj__CEpilogue__item___0 (Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.__internal_ocaml_attributes {CEpilogue? _} -> Prims.string
(declare-fun Tm_arrow_e37361b66babb46a30183ad1ff072689 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e37361b66babb46a30183ad1ff072689
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_e37361b66babb46a30183ad1ff072689
Tm_type)
:named kinding_Tm_arrow_e37361b66babb46a30183ad1ff072689))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,17-802,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,17-802,23)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_e37361b66babb46a30183ad1ff072689)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_e37361b66babb46a30183ad1ff072689))
:qid FStar.Pervasives_pre_typing_Tm_arrow_e37361b66babb46a30183ad1ff072689))

:named FStar.Pervasives_pre_typing_Tm_arrow_e37361b66babb46a30183ad1ff072689))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e37361b66babb46a30183ad1ff072689
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,17-802,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,17-802,23)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_e37361b66babb46a30183ad1ff072689)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,17-802,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(802,17-802,23)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_refine_47384bef739d1f0729fd782d351dc9a5)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_e37361b66babb46a30183ad1ff072689.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_e37361b66babb46a30183ad1ff072689))
:qid FStar.Pervasives_interpretation_Tm_arrow_e37361b66babb46a30183ad1ff072689))

:named FStar.Pervasives_interpretation_Tm_arrow_e37361b66babb46a30183ad1ff072689))
(declare-fun FStar.Pervasives.__proj__CEpilogue__item___0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CEpilogue__item___0@tok
@x0)
(FStar.Pervasives.__proj__CEpilogue__item___0 @x0))
 

:pattern ((ApplyTT FStar.Pervasives.__proj__CEpilogue__item___0@tok
@x0))
:qid token_correspondence_FStar.Pervasives.__proj__CEpilogue__item___0))
:named token_correspondence_FStar.Pervasives.__proj__CEpilogue__item___0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__CEpilogue__item___0@tok
Tm_arrow_e37361b66babb46a30183ad1ff072689))
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CEpilogue__item___0@tok
@x1)
(FStar.Pervasives.__proj__CEpilogue__item___0 @x1))
 

:pattern ((FStar.Pervasives.__proj__CEpilogue__item___0 @x1))
:qid function_token_typing_FStar.Pervasives.__proj__CEpilogue__item___0.1)))
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__CEpilogue__item___0@tok))
:qid function_token_typing_FStar.Pervasives.__proj__CEpilogue__item___0))
:named function_token_typing_FStar.Pervasives.__proj__CEpilogue__item___0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_refine_47384bef739d1f0729fd782d351dc9a5)
(HasType (FStar.Pervasives.__proj__CEpilogue__item___0 @x0)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__CEpilogue__item___0 @x0))
:qid typing_FStar.Pervasives.__proj__CEpilogue__item___0))
:named typing_FStar.Pervasives.__proj__CEpilogue__item___0))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__CEpilogue__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (FStar.Pervasives.__proj__CEpilogue__item___0 @x0)
(FStar.Pervasives.CEpilogue__0 @x0))
 

:pattern ((FStar.Pervasives.__proj__CEpilogue__item___0 @x0))
:qid proj_equation_FStar.Pervasives.CEpilogue__0))
:named proj_equation_FStar.Pervasives.CEpilogue__0))

; </end encoding FStar.Pervasives.__proj__CEpilogue__item___0>


; <Skipped FStar.Pervasives.__proj__CEpilogue__item___0/>


; <Start encoding FStar.Pervasives.uu___is_CConst>

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

(declare-fun FStar.Pervasives.uu___is_CConst@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CConst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CConst@tok
@x0)
(FStar.Pervasives.uu___is_CConst @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CConst@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CConst))

:named token_correspondence_FStar.Pervasives.uu___is_CConst))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CConst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CConst@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CConst@tok
@x1)
(FStar.Pervasives.uu___is_CConst @x1))
 

:pattern ((FStar.Pervasives.uu___is_CConst @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CConst.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CConst@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CConst))

:named function_token_typing_FStar.Pervasives.uu___is_CConst))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CConst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CConst @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CConst @x0))
:qid typing_FStar.Pervasives.uu___is_CConst))

:named typing_FStar.Pervasives.uu___is_CConst))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CConst; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CConst @x0)
(BoxBool (is-FStar.Pervasives.CConst @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CConst @x0))
:qid disc_equation_FStar.Pervasives.CConst))

:named disc_equation_FStar.Pervasives.CConst))

; </end encoding FStar.Pervasives.uu___is_CConst>


; <Skipped FStar.Pervasives.uu___is_CConst/>


; <Start encoding FStar.Pervasives.__proj__CConst__item___0>

(declare-fun Tm_refine_5036c6b2983454bc3afeffcba3f00f50 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_refine_5036c6b2983454bc3afeffcba3f00f50
Tm_type)
:named refinement_kinding_Tm_refine_5036c6b2983454bc3afeffcba3f00f50))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_5036c6b2983454bc3afeffcba3f00f50)
(and (HasTypeFuel @u0
@x1
FStar.Pervasives.__internal_ocaml_attributes)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,4-803,10)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_CConst @x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_5036c6b2983454bc3afeffcba3f00f50))
:qid refinement_interpretation_Tm_refine_5036c6b2983454bc3afeffcba3f00f50))

:named refinement_interpretation_Tm_refine_5036c6b2983454bc3afeffcba3f00f50))
;;;;;;;;;;;;;;;;haseq for Tm_refine_5036c6b2983454bc3afeffcba3f00f50
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (iff (Valid (Prims.hasEq Tm_refine_5036c6b2983454bc3afeffcba3f00f50))
(Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes)))
:named haseqTm_refine_5036c6b2983454bc3afeffcba3f00f50))
(declare-fun FStar.Pervasives.__proj__CConst__item___0 (Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.__internal_ocaml_attributes {CConst? _} -> Prims.string
(declare-fun Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a
Tm_type)
:named kinding_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,14-803,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,14-803,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))
:qid FStar.Pervasives_pre_typing_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))

:named FStar.Pervasives_pre_typing_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,14-803,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,14-803,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,14-803,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(803,14-803,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_refine_5036c6b2983454bc3afeffcba3f00f50)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))
:qid FStar.Pervasives_interpretation_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))

:named FStar.Pervasives_interpretation_Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))
(declare-fun FStar.Pervasives.__proj__CConst__item___0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CConst__item___0@tok
@x0)
(FStar.Pervasives.__proj__CConst__item___0 @x0))
 

:pattern ((ApplyTT FStar.Pervasives.__proj__CConst__item___0@tok
@x0))
:qid token_correspondence_FStar.Pervasives.__proj__CConst__item___0))
:named token_correspondence_FStar.Pervasives.__proj__CConst__item___0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__CConst__item___0@tok
Tm_arrow_2d0b7639551b88b0df758d7b36c8f77a))
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CConst__item___0@tok
@x1)
(FStar.Pervasives.__proj__CConst__item___0 @x1))
 

:pattern ((FStar.Pervasives.__proj__CConst__item___0 @x1))
:qid function_token_typing_FStar.Pervasives.__proj__CConst__item___0.1)))
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__CConst__item___0@tok))
:qid function_token_typing_FStar.Pervasives.__proj__CConst__item___0))
:named function_token_typing_FStar.Pervasives.__proj__CConst__item___0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_refine_5036c6b2983454bc3afeffcba3f00f50)
(HasType (FStar.Pervasives.__proj__CConst__item___0 @x0)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__CConst__item___0 @x0))
:qid typing_FStar.Pervasives.__proj__CConst__item___0))
:named typing_FStar.Pervasives.__proj__CConst__item___0))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__CConst__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (FStar.Pervasives.__proj__CConst__item___0 @x0)
(FStar.Pervasives.CConst__0 @x0))
 

:pattern ((FStar.Pervasives.__proj__CConst__item___0 @x0))
:qid proj_equation_FStar.Pervasives.CConst__0))
:named proj_equation_FStar.Pervasives.CConst__0))

; </end encoding FStar.Pervasives.__proj__CConst__item___0>


; <Skipped FStar.Pervasives.__proj__CConst__item___0/>


; <Start encoding FStar.Pervasives.uu___is_CCConv>

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

(declare-fun FStar.Pervasives.uu___is_CCConv@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CCConv; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CCConv@tok
@x0)
(FStar.Pervasives.uu___is_CCConv @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CCConv@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CCConv))

:named token_correspondence_FStar.Pervasives.uu___is_CCConv))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CCConv; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CCConv@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CCConv@tok
@x1)
(FStar.Pervasives.uu___is_CCConv @x1))
 

:pattern ((FStar.Pervasives.uu___is_CCConv @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CCConv.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CCConv@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CCConv))

:named function_token_typing_FStar.Pervasives.uu___is_CCConv))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CCConv; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CCConv @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CCConv @x0))
:qid typing_FStar.Pervasives.uu___is_CCConv))

:named typing_FStar.Pervasives.uu___is_CCConv))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CCConv; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CCConv @x0)
(BoxBool (is-FStar.Pervasives.CCConv @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CCConv @x0))
:qid disc_equation_FStar.Pervasives.CCConv))

:named disc_equation_FStar.Pervasives.CCConv))

; </end encoding FStar.Pervasives.uu___is_CCConv>


; <Skipped FStar.Pervasives.uu___is_CCConv/>


; <Start encoding FStar.Pervasives.__proj__CCConv__item___0>

(declare-fun Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320
Tm_type)
:named refinement_kinding_Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320)
(and (HasTypeFuel @u0
@x1
FStar.Pervasives.__internal_ocaml_attributes)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,4-809,10)
(BoxBool_proj_0 (FStar.Pervasives.uu___is_CCConv @x1))
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320))
:qid refinement_interpretation_Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320))

:named refinement_interpretation_Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320))
;;;;;;;;;;;;;;;;haseq for Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (iff (Valid (Prims.hasEq Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320))
(Valid (Prims.hasEq FStar.Pervasives.__internal_ocaml_attributes)))
:named haseqTm_refine_2c4510f48649a66c3dca1fc9e3a2d320))
(declare-fun FStar.Pervasives.__proj__CCConv__item___0 (Term) Term)

;;;;;;;;;;;;;;;;projectee: _: FStar.Pervasives.__internal_ocaml_attributes {CCConv? _} -> Prims.string
(declare-fun Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6
Tm_type)
:named kinding_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,14-809,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,14-809,20)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))
:qid FStar.Pervasives_pre_typing_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))

:named FStar.Pervasives_pre_typing_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,14-809,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,14-809,20)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,14-809,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(809,14-809,20)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320)
(HasType (ApplyTT @x0
@x1)
Prims.string))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))
:qid FStar.Pervasives_interpretation_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))

:named FStar.Pervasives_interpretation_Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))
(declare-fun FStar.Pervasives.__proj__CCConv__item___0@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CCConv__item___0@tok
@x0)
(FStar.Pervasives.__proj__CCConv__item___0 @x0))
 

:pattern ((ApplyTT FStar.Pervasives.__proj__CCConv__item___0@tok
@x0))
:qid token_correspondence_FStar.Pervasives.__proj__CCConv__item___0))
:named token_correspondence_FStar.Pervasives.__proj__CCConv__item___0))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.__proj__CCConv__item___0@tok
Tm_arrow_b7e884ec94708f2b05c42d4d8834eac6))
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.__proj__CCConv__item___0@tok
@x1)
(FStar.Pervasives.__proj__CCConv__item___0 @x1))
 

:pattern ((FStar.Pervasives.__proj__CCConv__item___0 @x1))
:qid function_token_typing_FStar.Pervasives.__proj__CCConv__item___0.1)))
 

:pattern ((ApplyTT @x0
FStar.Pervasives.__proj__CCConv__item___0@tok))
:qid function_token_typing_FStar.Pervasives.__proj__CCConv__item___0))
:named function_token_typing_FStar.Pervasives.__proj__CCConv__item___0))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_refine_2c4510f48649a66c3dca1fc9e3a2d320)
(HasType (FStar.Pervasives.__proj__CCConv__item___0 @x0)
Prims.string))
 

:pattern ((FStar.Pervasives.__proj__CCConv__item___0 @x0))
:qid typing_FStar.Pervasives.__proj__CCConv__item___0))
:named typing_FStar.Pervasives.__proj__CCConv__item___0))
;;;;;;;;;;;;;;;;Projector equation
;;; Fact-ids: Name FStar.Pervasives.__proj__CCConv__item___0; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term))
 (! (= (FStar.Pervasives.__proj__CCConv__item___0 @x0)
(FStar.Pervasives.CCConv__0 @x0))
 

:pattern ((FStar.Pervasives.__proj__CCConv__item___0 @x0))
:qid proj_equation_FStar.Pervasives.CCConv__0))
:named proj_equation_FStar.Pervasives.CCConv__0))

; </end encoding FStar.Pervasives.__proj__CCConv__item___0>


; <Skipped FStar.Pervasives.__proj__CCConv__item___0/>


; <Start encoding FStar.Pervasives.uu___is_CAbstractStruct>

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

(declare-fun FStar.Pervasives.uu___is_CAbstractStruct@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CAbstractStruct; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CAbstractStruct@tok
@x0)
(FStar.Pervasives.uu___is_CAbstractStruct @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CAbstractStruct@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CAbstractStruct))

:named token_correspondence_FStar.Pervasives.uu___is_CAbstractStruct))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CAbstractStruct; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CAbstractStruct@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CAbstractStruct@tok
@x1)
(FStar.Pervasives.uu___is_CAbstractStruct @x1))
 

:pattern ((FStar.Pervasives.uu___is_CAbstractStruct @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CAbstractStruct.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CAbstractStruct@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CAbstractStruct))

:named function_token_typing_FStar.Pervasives.uu___is_CAbstractStruct))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CAbstractStruct; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CAbstractStruct @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CAbstractStruct @x0))
:qid typing_FStar.Pervasives.uu___is_CAbstractStruct))

:named typing_FStar.Pervasives.uu___is_CAbstractStruct))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CAbstractStruct; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(810,4-810,19)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CAbstractStruct @x0)
(BoxBool (is-FStar.Pervasives.CAbstractStruct @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CAbstractStruct @x0))
:qid disc_equation_FStar.Pervasives.CAbstractStruct))

:named disc_equation_FStar.Pervasives.CAbstractStruct))

; </end encoding FStar.Pervasives.uu___is_CAbstractStruct>


; <Skipped FStar.Pervasives.uu___is_CAbstractStruct/>


; <Start encoding FStar.Pervasives.uu___is_CIfDef>

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

(declare-fun FStar.Pervasives.uu___is_CIfDef@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CIfDef; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CIfDef@tok
@x0)
(FStar.Pervasives.uu___is_CIfDef @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CIfDef@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CIfDef))

:named token_correspondence_FStar.Pervasives.uu___is_CIfDef))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CIfDef; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CIfDef@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CIfDef@tok
@x1)
(FStar.Pervasives.uu___is_CIfDef @x1))
 

:pattern ((FStar.Pervasives.uu___is_CIfDef @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CIfDef.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CIfDef@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CIfDef))

:named function_token_typing_FStar.Pervasives.uu___is_CIfDef))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CIfDef; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CIfDef @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CIfDef @x0))
:qid typing_FStar.Pervasives.uu___is_CIfDef))

:named typing_FStar.Pervasives.uu___is_CIfDef))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CIfDef; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(815,4-815,10)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CIfDef @x0)
(BoxBool (is-FStar.Pervasives.CIfDef @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CIfDef @x0))
:qid disc_equation_FStar.Pervasives.CIfDef))

:named disc_equation_FStar.Pervasives.CIfDef))

; </end encoding FStar.Pervasives.uu___is_CIfDef>


; <Skipped FStar.Pervasives.uu___is_CIfDef/>


; <Start encoding FStar.Pervasives.uu___is_CMacro>

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

(declare-fun FStar.Pervasives.uu___is_CMacro@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.uu___is_CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CMacro@tok
@x0)
(FStar.Pervasives.uu___is_CMacro @x0))
 

:pattern ((ApplyTT FStar.Pervasives.uu___is_CMacro@tok
@x0))
:qid token_correspondence_FStar.Pervasives.uu___is_CMacro))

:named token_correspondence_FStar.Pervasives.uu___is_CMacro))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.uu___is_CMacro@tok
Tm_arrow_89dc0c243f5e74d4fefc48cfe123db41))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.uu___is_CMacro@tok
@x1)
(FStar.Pervasives.uu___is_CMacro @x1))
 

:pattern ((FStar.Pervasives.uu___is_CMacro @x1))
:qid function_token_typing_FStar.Pervasives.uu___is_CMacro.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.uu___is_CMacro@tok))
:qid function_token_typing_FStar.Pervasives.uu___is_CMacro))

:named function_token_typing_FStar.Pervasives.uu___is_CMacro))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.uu___is_CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
FStar.Pervasives.__internal_ocaml_attributes)
(HasType (FStar.Pervasives.uu___is_CMacro @x0)
Prims.bool))
 

:pattern ((FStar.Pervasives.uu___is_CMacro @x0))
:qid typing_FStar.Pervasives.uu___is_CMacro))

:named typing_FStar.Pervasives.uu___is_CMacro))
;;;;;;;;;;;;;;;;Discriminator equation
;;; Fact-ids: Name FStar.Pervasives.uu___is_CMacro; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(816,4-816,10)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.uu___is_CMacro @x0)
(BoxBool (is-FStar.Pervasives.CMacro @x0)))
 

:pattern ((FStar.Pervasives.uu___is_CMacro @x0))
:qid disc_equation_FStar.Pervasives.CMacro))

:named disc_equation_FStar.Pervasives.CMacro))

; </end encoding FStar.Pervasives.uu___is_CMacro>


; <Skipped FStar.Pervasives.uu___is_CMacro/>


; <Start encoding FStar.Pervasives.inline_let>

(declare-fun FStar.Pervasives.inline_let (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.inline_let; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(825,4-825,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(825,4-825,14)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.inline_let @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.inline_let @u0))
:qid typing_FStar.Pervasives.inline_let))

:named typing_FStar.Pervasives.inline_let))

; </end encoding FStar.Pervasives.inline_let>


; <Start encoding FStar.Pervasives.rename_let>

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

(declare-fun FStar.Pervasives.rename_let@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.rename_let; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.rename_let@tok
@x0)
(FStar.Pervasives.rename_let @x0))
 

:pattern ((ApplyTT FStar.Pervasives.rename_let@tok
@x0))
:qid token_correspondence_FStar.Pervasives.rename_let))

:named token_correspondence_FStar.Pervasives.rename_let))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.rename_let; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.rename_let@tok
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.rename_let@tok
@x1)
(FStar.Pervasives.rename_let @x1))
 

:pattern ((FStar.Pervasives.rename_let @x1))
:qid function_token_typing_FStar.Pervasives.rename_let.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.rename_let@tok))
:qid function_token_typing_FStar.Pervasives.rename_let))

:named function_token_typing_FStar.Pervasives.rename_let))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.rename_let; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(834,4-834,14)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (FStar.Pervasives.rename_let @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.rename_let @x0))
:qid typing_FStar.Pervasives.rename_let))

:named typing_FStar.Pervasives.rename_let))

; </end encoding FStar.Pervasives.rename_let>


; <Start encoding FStar.Pervasives.plugin>

(declare-fun FStar.Pervasives.plugin (Term) Term)
;;;;;;;;;;;;;;;;x: Prims.int -> Prims.unit
(declare-fun Tm_arrow_f12575a0ee171a8be16a63e3359708f8 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f12575a0ee171a8be16a63e3359708f8
;;; Fact-ids: Name FStar.Pervasives.plugin; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f12575a0ee171a8be16a63e3359708f8
Tm_type)
:named kinding_Tm_arrow_f12575a0ee171a8be16a63e3359708f8))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.plugin; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,26-841,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,26-841,30)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f12575a0ee171a8be16a63e3359708f8)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f12575a0ee171a8be16a63e3359708f8))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f12575a0ee171a8be16a63e3359708f8))

:named FStar.Pervasives_pre_typing_Tm_arrow_f12575a0ee171a8be16a63e3359708f8))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f12575a0ee171a8be16a63e3359708f8
;;; Fact-ids: Name FStar.Pervasives.plugin; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,26-841,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,26-841,30)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f12575a0ee171a8be16a63e3359708f8)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,26-841,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,26-841,30)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.int)
(HasType (ApplyTT @x0
@x1)
Prims.unit))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f12575a0ee171a8be16a63e3359708f8.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f12575a0ee171a8be16a63e3359708f8))
:qid FStar.Pervasives_interpretation_Tm_arrow_f12575a0ee171a8be16a63e3359708f8))

:named FStar.Pervasives_interpretation_Tm_arrow_f12575a0ee171a8be16a63e3359708f8))
(declare-fun FStar.Pervasives.plugin@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.plugin; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.plugin@tok
@x0)
(FStar.Pervasives.plugin @x0))
 

:pattern ((ApplyTT FStar.Pervasives.plugin@tok
@x0))
:qid token_correspondence_FStar.Pervasives.plugin))

:named token_correspondence_FStar.Pervasives.plugin))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.plugin; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.plugin@tok
Tm_arrow_f12575a0ee171a8be16a63e3359708f8))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.plugin@tok
@x1)
(FStar.Pervasives.plugin @x1))
 

:pattern ((FStar.Pervasives.plugin @x1))
:qid function_token_typing_FStar.Pervasives.plugin.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.plugin@tok))
:qid function_token_typing_FStar.Pervasives.plugin))

:named function_token_typing_FStar.Pervasives.plugin))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.plugin; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(841,4-841,10)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.int)
(HasType (FStar.Pervasives.plugin @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.plugin @x0))
:qid typing_FStar.Pervasives.plugin))

:named typing_FStar.Pervasives.plugin))

; </end encoding FStar.Pervasives.plugin>


; <Start encoding FStar.Pervasives.tcnorm>

(declare-fun FStar.Pervasives.tcnorm (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.tcnorm; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(845,4-845,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(845,4-845,10)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.tcnorm @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.tcnorm @u0))
:qid typing_FStar.Pervasives.tcnorm))

:named typing_FStar.Pervasives.tcnorm))

; </end encoding FStar.Pervasives.tcnorm>


; <Start encoding FStar.Pervasives.must_erase_for_extraction>

(declare-fun FStar.Pervasives.must_erase_for_extraction (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.must_erase_for_extraction; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(860,4-860,29); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(860,4-860,29)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.must_erase_for_extraction @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.must_erase_for_extraction @u0))
:qid typing_FStar.Pervasives.must_erase_for_extraction))

:named typing_FStar.Pervasives.must_erase_for_extraction))

; </end encoding FStar.Pervasives.must_erase_for_extraction>


; <Start encoding FStar.Pervasives.dm4f_bind_range>

(declare-fun FStar.Pervasives.dm4f_bind_range (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.dm4f_bind_range; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(864,4-864,19); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(864,4-864,19)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.dm4f_bind_range @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.dm4f_bind_range @u0))
:qid typing_FStar.Pervasives.dm4f_bind_range))

:named typing_FStar.Pervasives.dm4f_bind_range))

; </end encoding FStar.Pervasives.dm4f_bind_range>


; <Start encoding FStar.Pervasives.expect_failure>

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

(declare-fun FStar.Pervasives.expect_failure@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.expect_failure; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.expect_failure@tok
@x0)
(FStar.Pervasives.expect_failure @x0))
 

:pattern ((ApplyTT FStar.Pervasives.expect_failure@tok
@x0))
:qid token_correspondence_FStar.Pervasives.expect_failure))

:named token_correspondence_FStar.Pervasives.expect_failure))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.expect_failure; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.expect_failure@tok
Tm_arrow_555d62757eeaf90340982fcdf25f6704))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.expect_failure@tok
@x1)
(FStar.Pervasives.expect_failure @x1))
 

:pattern ((FStar.Pervasives.expect_failure @x1))
:qid function_token_typing_FStar.Pervasives.expect_failure.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.expect_failure@tok))
:qid function_token_typing_FStar.Pervasives.expect_failure))

:named function_token_typing_FStar.Pervasives.expect_failure))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.expect_failure; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(871,4-871,18)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.int))
(HasType (FStar.Pervasives.expect_failure @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.expect_failure @x0))
:qid typing_FStar.Pervasives.expect_failure))

:named typing_FStar.Pervasives.expect_failure))

; </end encoding FStar.Pervasives.expect_failure>


; <Start encoding FStar.Pervasives.expect_lax_failure>

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

(declare-fun FStar.Pervasives.expect_lax_failure@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.expect_lax_failure; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.expect_lax_failure@tok
@x0)
(FStar.Pervasives.expect_lax_failure @x0))
 

:pattern ((ApplyTT FStar.Pervasives.expect_lax_failure@tok
@x0))
:qid token_correspondence_FStar.Pervasives.expect_lax_failure))

:named token_correspondence_FStar.Pervasives.expect_lax_failure))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.expect_lax_failure; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.expect_lax_failure@tok
Tm_arrow_555d62757eeaf90340982fcdf25f6704))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.expect_lax_failure@tok
@x1)
(FStar.Pervasives.expect_lax_failure @x1))
 

:pattern ((FStar.Pervasives.expect_lax_failure @x1))
:qid function_token_typing_FStar.Pervasives.expect_lax_failure.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.expect_lax_failure@tok))
:qid function_token_typing_FStar.Pervasives.expect_lax_failure))

:named function_token_typing_FStar.Pervasives.expect_lax_failure))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.expect_lax_failure; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(878,4-878,22)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.int))
(HasType (FStar.Pervasives.expect_lax_failure @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.expect_lax_failure @x0))
:qid typing_FStar.Pervasives.expect_lax_failure))

:named typing_FStar.Pervasives.expect_lax_failure))

; </end encoding FStar.Pervasives.expect_lax_failure>


; <Start encoding FStar.Pervasives.tcdecltime>

(declare-fun FStar.Pervasives.tcdecltime (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.tcdecltime; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(881,4-881,14); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(881,4-881,14)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.tcdecltime @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.tcdecltime @u0))
:qid typing_FStar.Pervasives.tcdecltime))

:named typing_FStar.Pervasives.tcdecltime))

; </end encoding FStar.Pervasives.tcdecltime>


; <Start encoding FStar.Pervasives.unifier_hint_injective>

(declare-fun FStar.Pervasives.unifier_hint_injective (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.unifier_hint_injective; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(889,4-889,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(889,4-889,26)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.unifier_hint_injective @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.unifier_hint_injective @u0))
:qid typing_FStar.Pervasives.unifier_hint_injective))

:named typing_FStar.Pervasives.unifier_hint_injective))

; </end encoding FStar.Pervasives.unifier_hint_injective>


; <Start encoding FStar.Pervasives.strict_on_arguments>

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

(declare-fun FStar.Pervasives.strict_on_arguments@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.strict_on_arguments; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.strict_on_arguments@tok
@x0)
(FStar.Pervasives.strict_on_arguments @x0))
 

:pattern ((ApplyTT FStar.Pervasives.strict_on_arguments@tok
@x0))
:qid token_correspondence_FStar.Pervasives.strict_on_arguments))

:named token_correspondence_FStar.Pervasives.strict_on_arguments))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.strict_on_arguments; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.strict_on_arguments@tok
Tm_arrow_555d62757eeaf90340982fcdf25f6704))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.strict_on_arguments@tok
@x1)
(FStar.Pervasives.strict_on_arguments @x1))
 

:pattern ((FStar.Pervasives.strict_on_arguments @x1))
:qid function_token_typing_FStar.Pervasives.strict_on_arguments.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.strict_on_arguments@tok))
:qid function_token_typing_FStar.Pervasives.strict_on_arguments))

:named function_token_typing_FStar.Pervasives.strict_on_arguments))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.strict_on_arguments; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(916,4-916,23)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list Prims.int))
(HasType (FStar.Pervasives.strict_on_arguments @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.strict_on_arguments @x0))
:qid typing_FStar.Pervasives.strict_on_arguments))

:named typing_FStar.Pervasives.strict_on_arguments))

; </end encoding FStar.Pervasives.strict_on_arguments>


; <Start encoding FStar.Pervasives.resolve_implicits>

(declare-fun FStar.Pervasives.resolve_implicits (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.resolve_implicits; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(922,4-922,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(922,4-922,21)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.resolve_implicits @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.resolve_implicits @u0))
:qid typing_FStar.Pervasives.resolve_implicits))

:named typing_FStar.Pervasives.resolve_implicits))

; </end encoding FStar.Pervasives.resolve_implicits>


; <Start encoding FStar.Pervasives.override_resolve_implicits_handler>

(declare-fun FStar.Pervasives.override_resolve_implicits_handler (Term Term Term) Term)
;;;;;;;;;;;;;;;;_: a -> _: Prims.list Prims.string -> Prims.unit
(declare-fun Tm_arrow_93e6548cfc250f7cc25301579d62a018 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_93e6548cfc250f7cc25301579d62a018
;;; Fact-ids: Name FStar.Pervasives.override_resolve_implicits_handler; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_93e6548cfc250f7cc25301579d62a018
Tm_type)
:named kinding_Tm_arrow_93e6548cfc250f7cc25301579d62a018))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.override_resolve_implicits_handler; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_93e6548cfc250f7cc25301579d62a018)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_93e6548cfc250f7cc25301579d62a018))
:qid FStar.Pervasives_pre_typing_Tm_arrow_93e6548cfc250f7cc25301579d62a018))

:named FStar.Pervasives_pre_typing_Tm_arrow_93e6548cfc250f7cc25301579d62a018))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_93e6548cfc250f7cc25301579d62a018
;;; Fact-ids: Name FStar.Pervasives.override_resolve_implicits_handler; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_93e6548cfc250f7cc25301579d62a018)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1)
(HasType @x3
(Prims.list Prims.string)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
Prims.unit))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_93e6548cfc250f7cc25301579d62a018.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_93e6548cfc250f7cc25301579d62a018.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,76-939,80)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_93e6548cfc250f7cc25301579d62a018.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_93e6548cfc250f7cc25301579d62a018))
:qid FStar.Pervasives_interpretation_Tm_arrow_93e6548cfc250f7cc25301579d62a018))

:named FStar.Pervasives_interpretation_Tm_arrow_93e6548cfc250f7cc25301579d62a018))
(declare-fun FStar.Pervasives.override_resolve_implicits_handler@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.override_resolve_implicits_handler; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.override_resolve_implicits_handler@tok
@x0)
@x1)
@x2)
(FStar.Pervasives.override_resolve_implicits_handler @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.override_resolve_implicits_handler@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Pervasives.override_resolve_implicits_handler))

:named token_correspondence_FStar.Pervasives.override_resolve_implicits_handler))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.override_resolve_implicits_handler; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.override_resolve_implicits_handler@tok
Tm_arrow_93e6548cfc250f7cc25301579d62a018))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.override_resolve_implicits_handler@tok
@x1)
@x2)
@x3)
(FStar.Pervasives.override_resolve_implicits_handler @x1
@x2
@x3))
 

:pattern ((FStar.Pervasives.override_resolve_implicits_handler @x1
@x2
@x3))
:qid function_token_typing_FStar.Pervasives.override_resolve_implicits_handler.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.override_resolve_implicits_handler@tok))
:qid function_token_typing_FStar.Pervasives.override_resolve_implicits_handler))

:named function_token_typing_FStar.Pervasives.override_resolve_implicits_handler))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.override_resolve_implicits_handler; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(939,4-939,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0)
(HasType @x2
(Prims.list Prims.string)))
(HasType (FStar.Pervasives.override_resolve_implicits_handler @x0
@x1
@x2)
Prims.unit))
 

:pattern ((FStar.Pervasives.override_resolve_implicits_handler @x0
@x1
@x2))
:qid typing_FStar.Pervasives.override_resolve_implicits_handler))

:named typing_FStar.Pervasives.override_resolve_implicits_handler))

; </end encoding FStar.Pervasives.override_resolve_implicits_handler>


; <Start encoding FStar.Pervasives.handle_smt_goals>

(declare-fun FStar.Pervasives.handle_smt_goals (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.handle_smt_goals; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(945,4-945,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(945,4-945,20)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.handle_smt_goals @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.handle_smt_goals @u0))
:qid typing_FStar.Pervasives.handle_smt_goals))

:named typing_FStar.Pervasives.handle_smt_goals))

; </end encoding FStar.Pervasives.handle_smt_goals>


; <Start encoding FStar.Pervasives.erasable>

(declare-fun FStar.Pervasives.erasable (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.erasable; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(956,4-956,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(956,4-956,12)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.erasable @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.erasable @u0))
:qid typing_FStar.Pervasives.erasable))

:named typing_FStar.Pervasives.erasable))

; </end encoding FStar.Pervasives.erasable>


; <Start encoding FStar.Pervasives.commute_nested_matches>

(declare-fun FStar.Pervasives.commute_nested_matches (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.commute_nested_matches; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(990,4-990,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(990,4-990,26)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.commute_nested_matches @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.commute_nested_matches @u0))
:qid typing_FStar.Pervasives.commute_nested_matches))

:named typing_FStar.Pervasives.commute_nested_matches))

; </end encoding FStar.Pervasives.commute_nested_matches>


; <Start encoding FStar.Pervasives.noextract_to>

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

(declare-fun FStar.Pervasives.noextract_to@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.noextract_to; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.noextract_to@tok
@x0)
(FStar.Pervasives.noextract_to @x0))
 

:pattern ((ApplyTT FStar.Pervasives.noextract_to@tok
@x0))
:qid token_correspondence_FStar.Pervasives.noextract_to))

:named token_correspondence_FStar.Pervasives.noextract_to))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.noextract_to; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.noextract_to@tok
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.noextract_to@tok
@x1)
(FStar.Pervasives.noextract_to @x1))
 

:pattern ((FStar.Pervasives.noextract_to @x1))
:qid function_token_typing_FStar.Pervasives.noextract_to.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.noextract_to@tok))
:qid function_token_typing_FStar.Pervasives.noextract_to))

:named function_token_typing_FStar.Pervasives.noextract_to))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.noextract_to; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(997,4-997,16)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (FStar.Pervasives.noextract_to @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.noextract_to @x0))
:qid typing_FStar.Pervasives.noextract_to))

:named typing_FStar.Pervasives.noextract_to))

; </end encoding FStar.Pervasives.noextract_to>


; <Start encoding FStar.Pervasives.normalize_for_extraction>

(declare-fun FStar.Pervasives.normalize_for_extraction (Term) Term)
;;;;;;;;;;;;;;;;steps: Prims.list FStar.Pervasives.norm_step -> Prims.unit
(declare-fun Tm_arrow_5a371649389ebd695db0478470787cef () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_5a371649389ebd695db0478470787cef
;;; Fact-ids: Name FStar.Pervasives.normalize_for_extraction; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_5a371649389ebd695db0478470787cef
Tm_type)
:named kinding_Tm_arrow_5a371649389ebd695db0478470787cef))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.normalize_for_extraction; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,58-1026,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,58-1026,62)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_5a371649389ebd695db0478470787cef)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_5a371649389ebd695db0478470787cef))
:qid FStar.Pervasives_pre_typing_Tm_arrow_5a371649389ebd695db0478470787cef))

:named FStar.Pervasives_pre_typing_Tm_arrow_5a371649389ebd695db0478470787cef))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_5a371649389ebd695db0478470787cef
;;; Fact-ids: Name FStar.Pervasives.normalize_for_extraction; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,58-1026,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,58-1026,62)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_5a371649389ebd695db0478470787cef)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,58-1026,62); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,58-1026,62)
(forall ((@x1 Term))
 (! (implies (HasType @x1
(Prims.list FStar.Pervasives.norm_step))
(HasType (ApplyTT @x0
@x1)
Prims.unit))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_5a371649389ebd695db0478470787cef.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_5a371649389ebd695db0478470787cef))
:qid FStar.Pervasives_interpretation_Tm_arrow_5a371649389ebd695db0478470787cef))

:named FStar.Pervasives_interpretation_Tm_arrow_5a371649389ebd695db0478470787cef))
(declare-fun FStar.Pervasives.normalize_for_extraction@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.normalize_for_extraction; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.normalize_for_extraction@tok
@x0)
(FStar.Pervasives.normalize_for_extraction @x0))
 

:pattern ((ApplyTT FStar.Pervasives.normalize_for_extraction@tok
@x0))
:qid token_correspondence_FStar.Pervasives.normalize_for_extraction))

:named token_correspondence_FStar.Pervasives.normalize_for_extraction))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.normalize_for_extraction; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.normalize_for_extraction@tok
Tm_arrow_5a371649389ebd695db0478470787cef))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.normalize_for_extraction@tok
@x1)
(FStar.Pervasives.normalize_for_extraction @x1))
 

:pattern ((FStar.Pervasives.normalize_for_extraction @x1))
:qid function_token_typing_FStar.Pervasives.normalize_for_extraction.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.normalize_for_extraction@tok))
:qid function_token_typing_FStar.Pervasives.normalize_for_extraction))

:named function_token_typing_FStar.Pervasives.normalize_for_extraction))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.normalize_for_extraction; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1026,4-1026,28)
(forall ((@x0 Term))
 (! (implies (HasType @x0
(Prims.list FStar.Pervasives.norm_step))
(HasType (FStar.Pervasives.normalize_for_extraction @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.normalize_for_extraction @x0))
:qid typing_FStar.Pervasives.normalize_for_extraction))

:named typing_FStar.Pervasives.normalize_for_extraction))

; </end encoding FStar.Pervasives.normalize_for_extraction>


; <Start encoding FStar.Pervasives.ite_soundness_by>

(declare-fun FStar.Pervasives.ite_soundness_by (Term) Term)
;;;;;;;;;;;;;;;;attribute: Prims.unit -> Prims.unit
(declare-fun Tm_arrow_0c55530a575bf8e94add46ffb548393c () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0c55530a575bf8e94add46ffb548393c
;;; Fact-ids: Name FStar.Pervasives.ite_soundness_by; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_0c55530a575bf8e94add46ffb548393c
Tm_type)
:named kinding_Tm_arrow_0c55530a575bf8e94add46ffb548393c))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.ite_soundness_by; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,44-1038,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,44-1038,48)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_0c55530a575bf8e94add46ffb548393c)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_0c55530a575bf8e94add46ffb548393c))
:qid FStar.Pervasives_pre_typing_Tm_arrow_0c55530a575bf8e94add46ffb548393c))

:named FStar.Pervasives_pre_typing_Tm_arrow_0c55530a575bf8e94add46ffb548393c))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0c55530a575bf8e94add46ffb548393c
;;; Fact-ids: Name FStar.Pervasives.ite_soundness_by; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,44-1038,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,44-1038,48)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_0c55530a575bf8e94add46ffb548393c)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,44-1038,48); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,44-1038,48)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.unit)
(HasType (ApplyTT @x0
@x1)
Prims.unit))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_0c55530a575bf8e94add46ffb548393c.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_0c55530a575bf8e94add46ffb548393c))
:qid FStar.Pervasives_interpretation_Tm_arrow_0c55530a575bf8e94add46ffb548393c))

:named FStar.Pervasives_interpretation_Tm_arrow_0c55530a575bf8e94add46ffb548393c))
(declare-fun FStar.Pervasives.ite_soundness_by@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.ite_soundness_by; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.ite_soundness_by@tok
@x0)
(FStar.Pervasives.ite_soundness_by @x0))
 

:pattern ((ApplyTT FStar.Pervasives.ite_soundness_by@tok
@x0))
:qid token_correspondence_FStar.Pervasives.ite_soundness_by))

:named token_correspondence_FStar.Pervasives.ite_soundness_by))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.ite_soundness_by; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.ite_soundness_by@tok
Tm_arrow_0c55530a575bf8e94add46ffb548393c))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.ite_soundness_by@tok
@x1)
(FStar.Pervasives.ite_soundness_by @x1))
 

:pattern ((FStar.Pervasives.ite_soundness_by @x1))
:qid function_token_typing_FStar.Pervasives.ite_soundness_by.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.ite_soundness_by@tok))
:qid function_token_typing_FStar.Pervasives.ite_soundness_by))

:named function_token_typing_FStar.Pervasives.ite_soundness_by))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.ite_soundness_by; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1038,4-1038,20)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.unit)
(HasType (FStar.Pervasives.ite_soundness_by @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.ite_soundness_by @x0))
:qid typing_FStar.Pervasives.ite_soundness_by))

:named typing_FStar.Pervasives.ite_soundness_by))

; </end encoding FStar.Pervasives.ite_soundness_by>


; <Start encoding FStar.Pervasives.default_effect>

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

(declare-fun FStar.Pervasives.default_effect@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.default_effect; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.default_effect@tok
@x0)
(FStar.Pervasives.default_effect @x0))
 

:pattern ((ApplyTT FStar.Pervasives.default_effect@tok
@x0))
:qid token_correspondence_FStar.Pervasives.default_effect))

:named token_correspondence_FStar.Pervasives.default_effect))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.default_effect; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.default_effect@tok
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.default_effect@tok
@x1)
(FStar.Pervasives.default_effect @x1))
 

:pattern ((FStar.Pervasives.default_effect @x1))
:qid function_token_typing_FStar.Pervasives.default_effect.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.default_effect@tok))
:qid function_token_typing_FStar.Pervasives.default_effect))

:named function_token_typing_FStar.Pervasives.default_effect))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.default_effect; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1054,4-1054,18)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (FStar.Pervasives.default_effect @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.default_effect @x0))
:qid typing_FStar.Pervasives.default_effect))

:named typing_FStar.Pervasives.default_effect))

; </end encoding FStar.Pervasives.default_effect>


; <Start encoding FStar.Pervasives.top_level_effect>

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

(declare-fun FStar.Pervasives.top_level_effect@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.top_level_effect; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.top_level_effect@tok
@x0)
(FStar.Pervasives.top_level_effect @x0))
 

:pattern ((ApplyTT FStar.Pervasives.top_level_effect@tok
@x0))
:qid token_correspondence_FStar.Pervasives.top_level_effect))

:named token_correspondence_FStar.Pervasives.top_level_effect))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.top_level_effect; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.top_level_effect@tok
Tm_arrow_2863eb88d7490a9c3cf347c16ca04740))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.top_level_effect@tok
@x1)
(FStar.Pervasives.top_level_effect @x1))
 

:pattern ((FStar.Pervasives.top_level_effect @x1))
:qid function_token_typing_FStar.Pervasives.top_level_effect.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.top_level_effect@tok))
:qid function_token_typing_FStar.Pervasives.top_level_effect))

:named function_token_typing_FStar.Pervasives.top_level_effect))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.top_level_effect; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1081,4-1081,20)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.string)
(HasType (FStar.Pervasives.top_level_effect @x0)
Prims.unit))
 

:pattern ((FStar.Pervasives.top_level_effect @x0))
:qid typing_FStar.Pervasives.top_level_effect))

:named typing_FStar.Pervasives.top_level_effect))

; </end encoding FStar.Pervasives.top_level_effect>


; <Start encoding FStar.Pervasives.effect_param>

(declare-fun FStar.Pervasives.effect_param (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.effect_param; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1091,4-1091,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1091,4-1091,16)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.effect_param @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.effect_param @u0))
:qid typing_FStar.Pervasives.effect_param))

:named typing_FStar.Pervasives.effect_param))

; </end encoding FStar.Pervasives.effect_param>


; <Start encoding FStar.Pervasives.bind_has_range_args>

(declare-fun FStar.Pervasives.bind_has_range_args (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.bind_has_range_args; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1099,4-1099,23); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1099,4-1099,23)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.bind_has_range_args @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.bind_has_range_args @u0))
:qid typing_FStar.Pervasives.bind_has_range_args))

:named typing_FStar.Pervasives.bind_has_range_args))

; </end encoding FStar.Pervasives.bind_has_range_args>


; <Start encoding FStar.Pervasives.strictly_positive>

(declare-fun FStar.Pervasives.strictly_positive (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.strictly_positive; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1109,4-1109,21); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1109,4-1109,21)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.strictly_positive @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.strictly_positive @u0))
:qid typing_FStar.Pervasives.strictly_positive))

:named typing_FStar.Pervasives.strictly_positive))

; </end encoding FStar.Pervasives.strictly_positive>


; <Start encoding FStar.Pervasives.no_auto_projectors>

(declare-fun FStar.Pervasives.no_auto_projectors (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.no_auto_projectors; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1121,4-1121,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1121,4-1121,22)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.no_auto_projectors @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.no_auto_projectors @u0))
:qid typing_FStar.Pervasives.no_auto_projectors))

:named typing_FStar.Pervasives.no_auto_projectors))

; </end encoding FStar.Pervasives.no_auto_projectors>


; <Start encoding FStar.Pervasives.no_subtyping>

(declare-fun FStar.Pervasives.no_subtyping (Dummy_sort) Term)
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.no_subtyping; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1129,4-1129,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1129,4-1129,16)
(forall ((@u0 Dummy_sort))
 (! (HasType (FStar.Pervasives.no_subtyping @u0)
Prims.unit)
 

:pattern ((FStar.Pervasives.no_subtyping @u0))
:qid typing_FStar.Pervasives.no_subtyping))

:named typing_FStar.Pervasives.no_subtyping))

; </end encoding FStar.Pervasives.no_subtyping>


; <Start encoding FStar.Pervasives.singleton>

(declare-fun FStar.Pervasives.singleton (Term Term) Term)
(declare-fun Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5))

:named refinement_kinding_Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x2
@x3))
(and (HasTypeFuel @u0
@x1
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,44-1137,50); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,44-1137,50)
(= @x1
@x3)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5))

:named refinement_interpretation_Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5))
;;;;;;;;;;;;;;;;haseq for Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x0
@x1)))
(Valid (Prims.hasEq @x0)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x0
@x1))))
:qid haseqTm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5))

:named haseqTm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5))
;;;;;;;;;;;;;;;;x: a -> y: a{y == x}
(declare-fun Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc
Tm_type)
:named kinding_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))
:qid FStar.Pervasives_pre_typing_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))

:named FStar.Pervasives_pre_typing_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
@x1))
(HasType (ApplyTT (ApplyTT @x0
@x1)
@x2)
(Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,38-1137,52)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc.2))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))
:qid FStar.Pervasives_interpretation_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))

:named FStar.Pervasives_interpretation_Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))
(declare-fun FStar.Pervasives.singleton@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.singleton@tok
@x0)
@x1)
(FStar.Pervasives.singleton @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.singleton@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.singleton))

:named token_correspondence_FStar.Pervasives.singleton))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.singleton@tok
Tm_arrow_9cdb4ebd85da757e86217b6fb07ef9fc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.singleton@tok
@x1)
@x2)
(FStar.Pervasives.singleton @x1
@x2))
 

:pattern ((FStar.Pervasives.singleton @x1
@x2))
:qid function_token_typing_FStar.Pervasives.singleton.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.singleton@tok))
:qid function_token_typing_FStar.Pervasives.singleton))

:named function_token_typing_FStar.Pervasives.singleton))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.singleton; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1137,4-1137,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.singleton @x0
@x1)
(Tm_refine_2fbd657fe85bcb2423f9c7e5f9b3bcb5 @x0
@x1)))
 

:pattern ((FStar.Pervasives.singleton @x0
@x1))
:qid typing_FStar.Pervasives.singleton))

:named typing_FStar.Pervasives.singleton))

; </end encoding FStar.Pervasives.singleton>


; <Start encoding FStar.Pervasives.with_type>

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

(declare-fun FStar.Pervasives.with_type@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.with_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13)
(forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.with_type@tok
@x0)
@x1)
(FStar.Pervasives.with_type @x0
@x1))
 

:pattern ((ApplyTT (ApplyTT FStar.Pervasives.with_type@tok
@x0)
@x1))
:qid token_correspondence_FStar.Pervasives.with_type))

:named token_correspondence_FStar.Pervasives.with_type))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.with_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.with_type@tok
Tm_arrow_99724436653747ac6f5a6a00c64ff8bc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13)
(forall ((@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT FStar.Pervasives.with_type@tok
@x1)
@x2)
(FStar.Pervasives.with_type @x1
@x2))
 

:pattern ((FStar.Pervasives.with_type @x1
@x2))
:qid function_token_typing_FStar.Pervasives.with_type.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.with_type@tok))
:qid function_token_typing_FStar.Pervasives.with_type))

:named function_token_typing_FStar.Pervasives.with_type))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.with_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1143,4-1143,13)
(forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
@x0))
(HasType (FStar.Pervasives.with_type @x0
@x1)
@x0))
 

:pattern ((FStar.Pervasives.with_type @x0
@x1))
:qid typing_FStar.Pervasives.with_type))

:named typing_FStar.Pervasives.with_type))
;;;;;;;;;;;;;;;;with_type primitive axiom
;;; Fact-ids: Name FStar.Pervasives.with_type; Namespace FStar.Pervasives
(assert (! (forall ((@x0 Term) (@x1 Term))
 (! (and (= (FStar.Pervasives.with_type @x0
@x1)
@x1)
(HasType (FStar.Pervasives.with_type @x0
@x1)
@x0))
 :weight 0


:pattern ((FStar.Pervasives.with_type @x0
@x1))
:qid @with_type_primitive_axiom))
:named @with_type_primitive_axiom))

; </end encoding FStar.Pervasives.with_type>


; <Start encoding FStar.Pervasives.eqtype_as_type>

(declare-fun FStar.Pervasives.eqtype_as_type (Term) Term)
;;;;;;;;;;;;;;;;a: Prims.eqtype -> Type
(declare-fun Tm_arrow_7e9afc6da5407011473323ad80ff51bf () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7e9afc6da5407011473323ad80ff51bf
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_7e9afc6da5407011473323ad80ff51bf
Tm_type)
:named kinding_Tm_arrow_7e9afc6da5407011473323ad80ff51bf))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,39-1149,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,39-1149,43)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_7e9afc6da5407011473323ad80ff51bf)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_7e9afc6da5407011473323ad80ff51bf))
:qid FStar.Pervasives_pre_typing_Tm_arrow_7e9afc6da5407011473323ad80ff51bf))

:named FStar.Pervasives_pre_typing_Tm_arrow_7e9afc6da5407011473323ad80ff51bf))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7e9afc6da5407011473323ad80ff51bf
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,39-1149,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,39-1149,43)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_7e9afc6da5407011473323ad80ff51bf)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,39-1149,43); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,39-1149,43)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.eqtype)
(HasType (ApplyTT @x0
@x1)
Tm_type))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_7e9afc6da5407011473323ad80ff51bf.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_7e9afc6da5407011473323ad80ff51bf))
:qid FStar.Pervasives_interpretation_Tm_arrow_7e9afc6da5407011473323ad80ff51bf))

:named FStar.Pervasives_interpretation_Tm_arrow_7e9afc6da5407011473323ad80ff51bf))
(declare-fun FStar.Pervasives.eqtype_as_type@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25)
(forall ((@x0 Term))
 (! (= (ApplyTT FStar.Pervasives.eqtype_as_type@tok
@x0)
(FStar.Pervasives.eqtype_as_type @x0))
 

:pattern ((ApplyTT FStar.Pervasives.eqtype_as_type@tok
@x0))
:qid token_correspondence_FStar.Pervasives.eqtype_as_type))

:named token_correspondence_FStar.Pervasives.eqtype_as_type))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.eqtype_as_type@tok
Tm_arrow_7e9afc6da5407011473323ad80ff51bf))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25)
(forall ((@x1 Term))
 (! (= (ApplyTT FStar.Pervasives.eqtype_as_type@tok
@x1)
(FStar.Pervasives.eqtype_as_type @x1))
 

:pattern ((FStar.Pervasives.eqtype_as_type @x1))
:qid function_token_typing_FStar.Pervasives.eqtype_as_type.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.eqtype_as_type@tok))
:qid function_token_typing_FStar.Pervasives.eqtype_as_type))

:named function_token_typing_FStar.Pervasives.eqtype_as_type))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.eqtype)
(HasType (FStar.Pervasives.eqtype_as_type @x0)
Tm_type))
 

:pattern ((FStar.Pervasives.eqtype_as_type @x0))
:qid typing_FStar.Pervasives.eqtype_as_type))

:named typing_FStar.Pervasives.eqtype_as_type))
;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.eqtype_as_type
;;; Fact-ids: Name FStar.Pervasives.eqtype_as_type; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1149,11-1149,25)
(forall ((@x0 Term))
 (! (= (FStar.Pervasives.eqtype_as_type @x0)
@x0)
 

:pattern ((FStar.Pervasives.eqtype_as_type @x0))
:qid equation_FStar.Pervasives.eqtype_as_type))

:named equation_FStar.Pervasives.eqtype_as_type))

; </end encoding FStar.Pervasives.eqtype_as_type>


; <Start encoding FStar.Pervasives.coerce_eq>

(declare-fun Tm_refine_0dee8cb03258a67c2f7ec66427696212 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_0dee8cb03258a67c2f7ec66427696212))

:named refinement_kinding_Tm_refine_0dee8cb03258a67c2f7ec66427696212))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52)
(= @x2
@x3)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_0dee8cb03258a67c2f7ec66427696212))

:named refinement_interpretation_Tm_refine_0dee8cb03258a67c2f7ec66427696212))
;;;;;;;;;;;;;;;;haseq for Tm_refine_0dee8cb03258a67c2f7ec66427696212
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,44-1155,52)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x0
@x1))))
:qid haseqTm_refine_0dee8cb03258a67c2f7ec66427696212))

:named haseqTm_refine_0dee8cb03258a67c2f7ec66427696212))
(declare-fun FStar.Pervasives.coerce_eq (Term Term Term Term) Term)

;;;;;;;;;;;;;;;;_: Prims.squash (a == b) -> x: a -> b
(declare-fun Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! (HasType Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8
Tm_type)
:named kinding_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,26-1155,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,62-1155,63)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))
:qid FStar.Pervasives_pre_typing_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))

:named FStar.Pervasives_pre_typing_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,26-1155,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,62-1155,63)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,26-1155,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,62-1155,63)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x1
@x2))
(HasType @x4
@x1))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Pervasives_interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,26-1155,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,62-1155,63)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Pervasives_interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,26-1155,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,62-1155,63)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Pervasives_interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,26-1155,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,62-1155,63)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Pervasives_interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))
:qid FStar.Pervasives_interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))

:named FStar.Pervasives_interpretation_Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))
(declare-fun FStar.Pervasives.coerce_eq@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.coerce_eq@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Pervasives.coerce_eq @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.coerce_eq@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Pervasives.coerce_eq))

:named token_correspondence_FStar.Pervasives.coerce_eq))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Pervasives.coerce_eq@tok
Tm_arrow_f44173fb14fa6046eedce5f32cb8aae8))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Pervasives.coerce_eq@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Pervasives.coerce_eq @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Pervasives.coerce_eq @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Pervasives.coerce_eq.1))
)
 

:pattern ((ApplyTT @x0
FStar.Pervasives.coerce_eq@tok))
:qid function_token_typing_FStar.Pervasives.coerce_eq))

:named function_token_typing_FStar.Pervasives.coerce_eq))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_0dee8cb03258a67c2f7ec66427696212 @x0
@x1))
(HasType @x3
@x0))
(HasType (FStar.Pervasives.coerce_eq @x0
@x1
@x2
@x3)
@x1))
 

:pattern ((FStar.Pervasives.coerce_eq @x0
@x1
@x2
@x3))
:qid typing_FStar.Pervasives.coerce_eq))

:named typing_FStar.Pervasives.coerce_eq))

;;;;;;;;;;;;;;;;Equation for FStar.Pervasives.coerce_eq
;;; Fact-ids: Name FStar.Pervasives.coerce_eq; Namespace FStar.Pervasives
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Pervasives.fsti(1155,4-1155,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Pervasives.coerce_eq @x0
@x1
@x2
@x3)
@x3)
 

:pattern ((FStar.Pervasives.coerce_eq @x0
@x1
@x2
@x3))
:qid equation_FStar.Pervasives.coerce_eq))

:named equation_FStar.Pervasives.coerce_eq))

; </end encoding FStar.Pervasives.coerce_eq>


; End Externals for interface FStar.Pervasives

;;; End interface FStar.Pervasives (2423 decls; total size 1132410)

;;; Start interface FStar.Classical.Sugar

; Externals for interface FStar.Classical.Sugar


; <Start encoding FStar.Classical.Sugar.forall_elim>


(declare-fun Tm_refine_eee646ed2c0261b2e37307734e5990b8 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_eee646ed2c0261b2e37307734e5990b8))

:named refinement_kinding_Tm_refine_eee646ed2c0261b2e37307734e5990b8))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,32-58,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,32-58,35)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,32-58,35); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,32-58,35)
(ApplyTT @x3
@x4)
)
)
 
;;no pats
:qid refinement_interpretation_Tm_refine_eee646ed2c0261b2e37307734e5990b8.1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_eee646ed2c0261b2e37307734e5990b8))

:named refinement_interpretation_Tm_refine_eee646ed2c0261b2e37307734e5990b8))
;;;;;;;;;;;;;;;;haseq for Tm_refine_eee646ed2c0261b2e37307734e5990b8
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(58,17-58,36)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x0
@x1))))
:qid haseqTm_refine_eee646ed2c0261b2e37307734e5990b8))

:named haseqTm_refine_eee646ed2c0261b2e37307734e5990b8))
(declare-fun FStar.Classical.Sugar.forall_elim (Term Term Term Term) Term)


;;;;;;;;;;;;;;;;v: a -> f: Prims.squash (forall (x: a). p x) -> Prims.squash (p v)
(declare-fun Tm_arrow_6fad81cdc8376c5921e448133045a0b5 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_6fad81cdc8376c5921e448133045a0b5
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_6fad81cdc8376c5921e448133045a0b5
Tm_type)
:named kinding_Tm_arrow_6fad81cdc8376c5921e448133045a0b5))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_6fad81cdc8376c5921e448133045a0b5)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_6fad81cdc8376c5921e448133045a0b5))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_6fad81cdc8376c5921e448133045a0b5))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_6fad81cdc8376c5921e448133045a0b5))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_6fad81cdc8376c5921e448133045a0b5)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
@x1)
(HasType @x4
(Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x1
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Prims.squash (ApplyTT @x2
@x3))))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(59,8-59,22)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_6fad81cdc8376c5921e448133045a0b5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_6fad81cdc8376c5921e448133045a0b5))
(declare-fun FStar.Classical.Sugar.forall_elim@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.forall_elim@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.forall_elim @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.forall_elim@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Classical.Sugar.forall_elim))

:named token_correspondence_FStar.Classical.Sugar.forall_elim))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.forall_elim@tok
Tm_arrow_6fad81cdc8376c5921e448133045a0b5))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.forall_elim@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Classical.Sugar.forall_elim @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Classical.Sugar.forall_elim @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Classical.Sugar.forall_elim.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.forall_elim@tok))
:qid function_token_typing_FStar.Classical.Sugar.forall_elim))

:named function_token_typing_FStar.Classical.Sugar.forall_elim))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.forall_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(54,4-54,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
@x0)
(HasType @x3
(Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x0
@x1)))
(HasType (FStar.Classical.Sugar.forall_elim @x0
@x1
@x2
@x3)
(Prims.squash (ApplyTT @x1
@x2))))
 

:pattern ((FStar.Classical.Sugar.forall_elim @x0
@x1
@x2
@x3))
:qid typing_FStar.Classical.Sugar.forall_elim))

:named typing_FStar.Classical.Sugar.forall_elim))

; </end encoding FStar.Classical.Sugar.forall_elim>


; <Start encoding FStar.Classical.Sugar.exists_elim>


(declare-fun Tm_refine_df2d65c00128265e81a98d1694fa32db (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_df2d65c00128265e81a98d1694fa32db @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_df2d65c00128265e81a98d1694fa32db @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_df2d65c00128265e81a98d1694fa32db))

:named refinement_kinding_Tm_refine_df2d65c00128265e81a98d1694fa32db))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41)
(exists ((@x4 Term))
 (! (and (HasType @x4
@x2)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,37-66,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,37-66,40)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,37-66,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,37-66,40)
(ApplyTT @x3
@x4)
)
)
 
;;no pats
:qid refinement_interpretation_Tm_refine_df2d65c00128265e81a98d1694fa32db.1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x2
@x3)))
:qid refinement_interpretation_Tm_refine_df2d65c00128265e81a98d1694fa32db))

:named refinement_interpretation_Tm_refine_df2d65c00128265e81a98d1694fa32db))
;;;;;;;;;;;;;;;;haseq for Tm_refine_df2d65c00128265e81a98d1694fa32db
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_df2d65c00128265e81a98d1694fa32db @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_df2d65c00128265e81a98d1694fa32db @x0
@x1))))
:qid haseqTm_refine_df2d65c00128265e81a98d1694fa32db))

:named haseqTm_refine_df2d65c00128265e81a98d1694fa32db))
;;;;;;;;;;;;;;;;x: t -> _: Prims.squash (p x) -> Prims.squash q
(declare-fun Tm_arrow_757abf2ff34845ceba7272f2bf4c779d (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d))

:named kinding_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x2
@x3
@x4)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@x3)
(HasType @x5
(Prims.squash (ApplyTT @x2
@x4))))
(HasType (ApplyTT (ApplyTT @x0
@x4)
@x5)
(Prims.squash @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@x3)
(IsTotFun (ApplyTT @x0
@x4)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x1
@x2
@x3)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_757abf2ff34845ceba7272f2bf4c779d))
(declare-fun FStar.Classical.Sugar.exists_elim (Term Term Term Term Term) Term)



;;;;;;;;;;;;;;;;$s_ex_p: Prims.squash (exists (x: t). p x) -> f: (x: t -> _: Prims.squash (p x) -> Prims.squash q)   -> Prims.squash q
(declare-fun Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6
Tm_type)
:named kinding_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x1
@x2))
(HasType @x5
(Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x3
@x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
(Prims.squash @x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(68,8-68,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))
(declare-fun FStar.Classical.Sugar.exists_elim@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.exists_elim@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Classical.Sugar.exists_elim @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.exists_elim@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Classical.Sugar.exists_elim))

:named token_correspondence_FStar.Classical.Sugar.exists_elim))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.exists_elim@tok
Tm_arrow_8a831fa0f832c0a8df6d5207189d1bd6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.exists_elim@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Classical.Sugar.exists_elim @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Classical.Sugar.exists_elim @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Classical.Sugar.exists_elim.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.exists_elim@tok))
:qid function_token_typing_FStar.Classical.Sugar.exists_elim))

:named function_token_typing_FStar.Classical.Sugar.exists_elim))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.exists_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(62,4-62,15)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x0
@x1))
(HasType @x4
(Tm_arrow_757abf2ff34845ceba7272f2bf4c779d @x2
@x1
@x0)))
(HasType (FStar.Classical.Sugar.exists_elim @x0
@x1
@x2
@x3
@x4)
(Prims.squash @x2)))
 

:pattern ((FStar.Classical.Sugar.exists_elim @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Classical.Sugar.exists_elim))

:named typing_FStar.Classical.Sugar.exists_elim))

; </end encoding FStar.Classical.Sugar.exists_elim>


; <Start encoding FStar.Classical.Sugar.implies_elim>

(declare-fun Tm_refine_913239c2cf9dc8a14e1f047e0206138d (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_913239c2cf9dc8a14e1f047e0206138d))

:named refinement_kinding_Tm_refine_913239c2cf9dc8a14e1f047e0206138d))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(73,9-73,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,19-75,20)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(73,9-73,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,19-75,20)
@x2
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(74,9-74,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,25-75,26)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(74,9-74,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,25-75,26)
@x3
)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x2
@x3)))
:qid refinement_interpretation_Tm_refine_913239c2cf9dc8a14e1f047e0206138d))

:named refinement_interpretation_Tm_refine_913239c2cf9dc8a14e1f047e0206138d))
;;;;;;;;;;;;;;;;haseq for Tm_refine_913239c2cf9dc8a14e1f047e0206138d
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(75,18-75,27)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x0
@x1))))
:qid haseqTm_refine_913239c2cf9dc8a14e1f047e0206138d))

:named haseqTm_refine_913239c2cf9dc8a14e1f047e0206138d))
;;;;;;;;;;;;;;;;_: Prims.unit -> Prims.squash p
(declare-fun Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x0)
Tm_type))
:qid kinding_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84))

:named kinding_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x2)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(76,23-76,33)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Prims.unit)
(HasType (ApplyTT @x0
@x2)
(Prims.squash @x1)))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x1)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_e5bf96e6b202d44baf035cb07df2da84))
(declare-fun FStar.Classical.Sugar.implies_elim (Term Term Term Term) Term)


;;;;;;;;;;;;;;;;p: Type -> q: Type -> _: Prims.squash (p ==> q) -> f: (_: Prims.unit -> Prims.squash p)   -> Prims.squash q
(declare-fun Tm_arrow_08b9f1333754078ddc08d25d2c8efab0 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_08b9f1333754078ddc08d25d2c8efab0
Tm_type)
:named kinding_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_08b9f1333754078ddc08d25d2c8efab0)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_08b9f1333754078ddc08d25d2c8efab0)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x1
@x2))
(HasType @x4
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Prims.squash @x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(77,4-77,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))
(declare-fun FStar.Classical.Sugar.implies_elim@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.implies_elim@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.implies_elim @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.implies_elim@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Classical.Sugar.implies_elim))

:named token_correspondence_FStar.Classical.Sugar.implies_elim))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.implies_elim@tok
Tm_arrow_08b9f1333754078ddc08d25d2c8efab0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.implies_elim@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Classical.Sugar.implies_elim @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Classical.Sugar.implies_elim @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Classical.Sugar.implies_elim.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.implies_elim@tok))
:qid function_token_typing_FStar.Classical.Sugar.implies_elim))

:named function_token_typing_FStar.Classical.Sugar.implies_elim))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
Tm_type)
(HasType @x2
(Tm_refine_913239c2cf9dc8a14e1f047e0206138d @x0
@x1))
(HasType @x3
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x0)))
(HasType (FStar.Classical.Sugar.implies_elim @x0
@x1
@x2
@x3)
(Prims.squash @x1)))
 

:pattern ((FStar.Classical.Sugar.implies_elim @x0
@x1
@x2
@x3))
:qid typing_FStar.Classical.Sugar.implies_elim))

:named typing_FStar.Classical.Sugar.implies_elim))


;;;;;;;;;;;;;;;;Equation for FStar.Classical.Sugar.implies_elim
;;; Fact-ids: Name FStar.Classical.Sugar.implies_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(72,4-72,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (FStar.Classical.Sugar.implies_elim @x0
@x1
@x2
@x3)
Tm_unit)
 

:pattern ((FStar.Classical.Sugar.implies_elim @x0
@x1
@x2
@x3))
:qid equation_FStar.Classical.Sugar.implies_elim))

:named equation_FStar.Classical.Sugar.implies_elim))

; </end encoding FStar.Classical.Sugar.implies_elim>


; <Start encoding FStar.Classical.Sugar.or_elim>

(declare-fun Tm_refine_953a6e4e702e848a7213bd619baaa22d (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_953a6e4e702e848a7213bd619baaa22d @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_953a6e4e702e848a7213bd619baaa22d @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_953a6e4e702e848a7213bd619baaa22d))

:named refinement_kinding_Tm_refine_953a6e4e702e848a7213bd619baaa22d))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_953a6e4e702e848a7213bd619baaa22d @x2))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22)
(not 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(85,9-85,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,20-86,21)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(85,9-85,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,20-86,21)
@x2
)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_953a6e4e702e848a7213bd619baaa22d @x2)))
:qid refinement_interpretation_Tm_refine_953a6e4e702e848a7213bd619baaa22d))

:named refinement_interpretation_Tm_refine_953a6e4e702e848a7213bd619baaa22d))
;;;;;;;;;;;;;;;;haseq for Tm_refine_953a6e4e702e848a7213bd619baaa22d
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,18-86,22)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_953a6e4e702e848a7213bd619baaa22d @x0)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_953a6e4e702e848a7213bd619baaa22d @x0))))
:qid haseqTm_refine_953a6e4e702e848a7213bd619baaa22d))

:named haseqTm_refine_953a6e4e702e848a7213bd619baaa22d))
;;;;;;;;;;;;;;;;_: Prims.squash (~p) -> Type
(declare-fun Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x0)
Tm_type))
:qid kinding_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9))

:named kinding_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x2)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(86,26-86,30)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(Tm_refine_953a6e4e702e848a7213bd619baaa22d @x1))
(HasType (ApplyTT @x0
@x2)
Tm_type))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9))
(declare-fun Tm_refine_044452ce08fa2077b813992baef379a7 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_044452ce08fa2077b813992baef379a7))

:named refinement_kinding_Tm_refine_044452ce08fa2077b813992baef379a7))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_044452ce08fa2077b813992baef379a7 @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31)
(or 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(85,9-85,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,22-88,23)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(85,9-85,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,22-88,23)
@x2
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,27-88,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,27-88,30)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,27-88,30); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,27-88,30)
(ApplyTT @x3
Tm_unit)
)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_044452ce08fa2077b813992baef379a7 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_044452ce08fa2077b813992baef379a7))

:named refinement_interpretation_Tm_refine_044452ce08fa2077b813992baef379a7))
;;;;;;;;;;;;;;;;haseq for Tm_refine_044452ce08fa2077b813992baef379a7
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(88,21-88,31)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1))))
:qid haseqTm_refine_044452ce08fa2077b813992baef379a7))

:named haseqTm_refine_044452ce08fa2077b813992baef379a7))
;;;;;;;;;;;;;;;;_: Prims.squash p -> Prims.squash r
(declare-fun Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833))

:named kinding_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x2
@x3)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(89,30-89,40)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(Prims.squash @x2))
(HasType (ApplyTT @x0
@x3)
(Prims.squash @x1)))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x1
@x2)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833))

;;;;;;;;;;;;;;;;_: Prims.squash (~p) -> _: Prims.squash (q ()) -> Prims.squash r
(declare-fun Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25))

:named kinding_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x2
@x3
@x4)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(Tm_refine_953a6e4e702e848a7213bd619baaa22d @x3))
(HasType @x5
(Prims.squash (ApplyTT @x2
Tm_unit))))
(HasType (ApplyTT (ApplyTT @x0
@x4)
@x5)
(Prims.squash @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(90,50-90,60)
(forall ((@x4 Term))
 (! (implies (HasType @x4
(Tm_refine_953a6e4e702e848a7213bd619baaa22d @x3))
(IsTotFun (ApplyTT @x0
@x4)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x1
@x2
@x3)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25))
(declare-fun FStar.Classical.Sugar.or_elim (Term Term Term Term Term Term) Term)






;;;;;;;;;;;;;;;;p: Type ->     q: (_: Prims.squash (~p) -> Type) ->     r: Type ->     p_or: Prims.squash (p \/ q ()) ->     left: (_: Prims.squash p -> Prims.squash r) ->     right: (_: Prims.squash (~p) -> _: Prims.squash (q ()) -> Prims.squash r)   -> Prims.squash r
(declare-fun Tm_arrow_cd3704184434b709df08ad54743b9ddc () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_cd3704184434b709df08ad54743b9ddc
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_cd3704184434b709df08ad54743b9ddc
Tm_type)
:named kinding_Tm_arrow_cd3704184434b709df08ad54743b9ddc))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_cd3704184434b709df08ad54743b9ddc)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_cd3704184434b709df08ad54743b9ddc))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_cd3704184434b709df08ad54743b9ddc))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_cd3704184434b709df08ad54743b9ddc))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_cd3704184434b709df08ad54743b9ddc)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_044452ce08fa2077b813992baef379a7 @x1
@x2))
(HasType @x5
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x3
@x1))
(HasType @x6
(Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x3
@x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(Prims.squash @x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
@x6))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_044452ce08fa2077b813992baef379a7 @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(91,8-91,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_044452ce08fa2077b813992baef379a7 @x1
@x2))
(HasType @x5
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x3
@x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc.6))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_cd3704184434b709df08ad54743b9ddc))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_cd3704184434b709df08ad54743b9ddc))
(declare-fun FStar.Classical.Sugar.or_elim@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_elim@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Classical.Sugar.or_elim @x0
@x1
@x2
@x3
@x4
@x5))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_elim@tok
@x0)
@x1)
@x2)
@x3)
@x4)
@x5))
:qid token_correspondence_FStar.Classical.Sugar.or_elim))

:named token_correspondence_FStar.Classical.Sugar.or_elim))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.or_elim@tok
Tm_arrow_cd3704184434b709df08ad54743b9ddc))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_elim@tok
@x1)
@x2)
@x3)
@x4)
@x5)
@x6)
(FStar.Classical.Sugar.or_elim @x1
@x2
@x3
@x4
@x5
@x6))
 

:pattern ((FStar.Classical.Sugar.or_elim @x1
@x2
@x3
@x4
@x5
@x6))
:qid function_token_typing_FStar.Classical.Sugar.or_elim.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.or_elim@tok))
:qid function_token_typing_FStar.Classical.Sugar.or_elim))

:named function_token_typing_FStar.Classical.Sugar.or_elim))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.or_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(84,4-84,11)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x0))
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1))
(HasType @x4
(Tm_arrow_9d84457d1c8d2a3cb1cecf47a390b833 @x2
@x0))
(HasType @x5
(Tm_arrow_3cd50b91a1a8ff7ae2a33f725c49ca25 @x2
@x1
@x0)))
(HasType (FStar.Classical.Sugar.or_elim @x0
@x1
@x2
@x3
@x4
@x5)
(Prims.squash @x2)))
 

:pattern ((FStar.Classical.Sugar.or_elim @x0
@x1
@x2
@x3
@x4
@x5))
:qid typing_FStar.Classical.Sugar.or_elim))

:named typing_FStar.Classical.Sugar.or_elim))

; </end encoding FStar.Classical.Sugar.or_elim>


; <Start encoding FStar.Classical.Sugar.and_elim>

;;;;;;;;;;;;;;;;_: Prims.squash p -> Type
(declare-fun Tm_arrow_e617226e5c485cfca90836a8d37dc422 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e617226e5c485cfca90836a8d37dc422
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x0)
Tm_type))
:qid kinding_Tm_arrow_e617226e5c485cfca90836a8d37dc422))

:named kinding_Tm_arrow_e617226e5c485cfca90836a8d37dc422))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x2)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_e617226e5c485cfca90836a8d37dc422))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_e617226e5c485cfca90836a8d37dc422))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e617226e5c485cfca90836a8d37dc422
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(98,23-98,27)
(forall ((@x2 Term))
 (! (implies (HasType @x2
(Prims.squash @x1))
(HasType (ApplyTT @x0
@x2)
Tm_type))
 

:pattern ((ApplyTT @x0
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_e617226e5c485cfca90836a8d37dc422.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_e617226e5c485cfca90836a8d37dc422))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_e617226e5c485cfca90836a8d37dc422))
(declare-fun Tm_refine_0e6764ea7cf9747bf338120e46774802 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,18-100,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,18-100,28)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_0e6764ea7cf9747bf338120e46774802 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_0e6764ea7cf9747bf338120e46774802 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_0e6764ea7cf9747bf338120e46774802))

:named refinement_kinding_Tm_refine_0e6764ea7cf9747bf338120e46774802))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,18-100,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,18-100,28)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(97,9-97,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,19-100,20)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(97,9-97,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,19-100,20)
@x2
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,24-100,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,24-100,27)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,24-100,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,24-100,27)
(ApplyTT @x3
Tm_unit)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_0e6764ea7cf9747bf338120e46774802))

:named refinement_interpretation_Tm_refine_0e6764ea7cf9747bf338120e46774802))
;;;;;;;;;;;;;;;;haseq for Tm_refine_0e6764ea7cf9747bf338120e46774802
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,18-100,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(100,18-100,28)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_0e6764ea7cf9747bf338120e46774802 @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_0e6764ea7cf9747bf338120e46774802 @x0
@x1))))
:qid haseqTm_refine_0e6764ea7cf9747bf338120e46774802))

:named haseqTm_refine_0e6764ea7cf9747bf338120e46774802))
;;;;;;;;;;;;;;;;_: Prims.squash p -> _: Prims.squash (q ()) -> Prims.squash r
(declare-fun Tm_arrow_9cf3fa74bead5ce84576f320b610d107 (Term Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9cf3fa74bead5ce84576f320b610d107
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (HasType (Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x0
@x1
@x2)
Tm_type)
 

:pattern ((HasType (Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x0
@x1
@x2)
Tm_type))
:qid kinding_Tm_arrow_9cf3fa74bead5ce84576f320b610d107))

:named kinding_Tm_arrow_9cf3fa74bead5ce84576f320b610d107))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x2
@x3
@x4))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x2
@x3
@x4)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_9cf3fa74bead5ce84576f320b610d107))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_9cf3fa74bead5ce84576f320b610d107))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9cf3fa74bead5ce84576f320b610d107
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x1
@x2
@x3))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53)
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
(Prims.squash @x3))
(HasType @x5
(Prims.squash (ApplyTT @x2
Tm_unit))))
(HasType (ApplyTT (ApplyTT @x0
@x4)
@x5)
(Prims.squash @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x4)
@x5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_9cf3fa74bead5ce84576f320b610d107.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(101,43-101,53)
(forall ((@x4 Term))
 (! (implies (HasType @x4
(Prims.squash @x3))
(IsTotFun (ApplyTT @x0
@x4)))
 

:pattern ((ApplyTT @x0
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_9cf3fa74bead5ce84576f320b610d107.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x1
@x2
@x3)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_9cf3fa74bead5ce84576f320b610d107))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_9cf3fa74bead5ce84576f320b610d107))
(declare-fun FStar.Classical.Sugar.and_elim (Term Term Term Term Term) Term)



;;;;;;;;;;;;;;;;p: Type ->     q: (_: Prims.squash p -> Type) ->     r: Type ->     _: Prims.squash (p /\ q ()) ->     f: (_: Prims.squash p -> _: Prims.squash (q ()) -> Prims.squash r)   -> Prims.squash r
(declare-fun Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427
Tm_type)
:named kinding_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x1
@x2))
(HasType @x5
(Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x3
@x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5)
(Prims.squash @x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
@x5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(HasType @x3
Tm_type))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427.4))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(102,8-102,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(HasType @x3
Tm_type)
(HasType @x4
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x1
@x2)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427.5))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))
(declare-fun FStar.Classical.Sugar.and_elim@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.and_elim@tok
@x0)
@x1)
@x2)
@x3)
@x4)
(FStar.Classical.Sugar.and_elim @x0
@x1
@x2
@x3
@x4))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.and_elim@tok
@x0)
@x1)
@x2)
@x3)
@x4))
:qid token_correspondence_FStar.Classical.Sugar.and_elim))

:named token_correspondence_FStar.Classical.Sugar.and_elim))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.and_elim@tok
Tm_arrow_46e93521f3e2b84feb3b4c45d4b82427))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.and_elim@tok
@x1)
@x2)
@x3)
@x4)
@x5)
(FStar.Classical.Sugar.and_elim @x1
@x2
@x3
@x4
@x5))
 

:pattern ((FStar.Classical.Sugar.and_elim @x1
@x2
@x3
@x4
@x5))
:qid function_token_typing_FStar.Classical.Sugar.and_elim.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.and_elim@tok))
:qid function_token_typing_FStar.Classical.Sugar.and_elim))

:named function_token_typing_FStar.Classical.Sugar.and_elim))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.and_elim; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(96,4-96,12)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x0))
(HasType @x2
Tm_type)
(HasType @x3
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x0
@x1))
(HasType @x4
(Tm_arrow_9cf3fa74bead5ce84576f320b610d107 @x2
@x1
@x0)))
(HasType (FStar.Classical.Sugar.and_elim @x0
@x1
@x2
@x3
@x4)
(Prims.squash @x2)))
 

:pattern ((FStar.Classical.Sugar.and_elim @x0
@x1
@x2
@x3
@x4))
:qid typing_FStar.Classical.Sugar.and_elim))

:named typing_FStar.Classical.Sugar.and_elim))

; </end encoding FStar.Classical.Sugar.and_elim>


; <Start encoding FStar.Classical.Sugar.forall_intro>


;;;;;;;;;;;;;;;;x: a -> Prims.squash (p x)
(declare-fun Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1))

:named kinding_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x2
@x3)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(108,22-108,36)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@x2)
(HasType (ApplyTT @x0
@x3)
(Prims.squash (ApplyTT @x1
@x3))))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x1
@x2)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_e44b1a1960e76c65248b9976ee453bf1))
(declare-fun FStar.Classical.Sugar.forall_intro (Term Term Term) Term)



;;;;;;;;;;;;;;;;a: Type -> p: (_: a -> Type) -> f: (x: a -> Prims.squash (p x)) -> Prims.squash (forall (x: a). p x)
(declare-fun Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526
Tm_type)
:named kinding_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
(Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(109,8-109,32)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))
(declare-fun FStar.Classical.Sugar.forall_intro@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.forall_intro@tok
@x0)
@x1)
@x2)
(FStar.Classical.Sugar.forall_intro @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.forall_intro@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Classical.Sugar.forall_intro))

:named token_correspondence_FStar.Classical.Sugar.forall_intro))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.forall_intro@tok
Tm_arrow_810fc5a930eab84e2e1c9bc10e65f526))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.forall_intro@tok
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.forall_intro @x1
@x2
@x3))
 

:pattern ((FStar.Classical.Sugar.forall_intro @x1
@x2
@x3))
:qid function_token_typing_FStar.Classical.Sugar.forall_intro.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.forall_intro@tok))
:qid function_token_typing_FStar.Classical.Sugar.forall_intro))

:named function_token_typing_FStar.Classical.Sugar.forall_intro))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.forall_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(105,4-105,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
(Tm_arrow_e44b1a1960e76c65248b9976ee453bf1 @x1
@x0)))
(HasType (FStar.Classical.Sugar.forall_intro @x0
@x1
@x2)
(Tm_refine_eee646ed2c0261b2e37307734e5990b8 @x0
@x1)))
 

:pattern ((FStar.Classical.Sugar.forall_intro @x0
@x1
@x2))
:qid typing_FStar.Classical.Sugar.forall_intro))

:named typing_FStar.Classical.Sugar.forall_intro))

; </end encoding FStar.Classical.Sugar.forall_intro>


; <Start encoding FStar.Classical.Sugar.exists_intro>


;;;;;;;;;;;;;;;;_: Prims.unit -> Prims.squash (p v)
(declare-fun Tm_arrow_1f559753133c819dcbab21eb87f04504 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_1f559753133c819dcbab21eb87f04504
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_1f559753133c819dcbab21eb87f04504 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_1f559753133c819dcbab21eb87f04504 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_1f559753133c819dcbab21eb87f04504))

:named kinding_Tm_arrow_1f559753133c819dcbab21eb87f04504))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_1f559753133c819dcbab21eb87f04504 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_1f559753133c819dcbab21eb87f04504 @x2
@x3)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_1f559753133c819dcbab21eb87f04504))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_1f559753133c819dcbab21eb87f04504))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_1f559753133c819dcbab21eb87f04504
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_1f559753133c819dcbab21eb87f04504 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(116,24-116,38)
(forall ((@x3 Term))
 (! (implies (HasType @x3
Prims.unit)
(HasType (ApplyTT @x0
@x3)
(Prims.squash (ApplyTT @x2
@x1))))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_1f559753133c819dcbab21eb87f04504.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_1f559753133c819dcbab21eb87f04504 @x1
@x2)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_1f559753133c819dcbab21eb87f04504))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_1f559753133c819dcbab21eb87f04504))
(declare-fun FStar.Classical.Sugar.exists_intro (Term Term Term Term) Term)



;;;;;;;;;;;;;;;;a: Type -> p: (_: a -> Type) -> v: a -> x: (_: Prims.unit -> Prims.squash (p v))   -> Prims.squash (exists (x: a). p x)
(declare-fun Tm_arrow_98a6ce57193d862f12aa770d807de2d6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_98a6ce57193d862f12aa770d807de2d6
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_98a6ce57193d862f12aa770d807de2d6
Tm_type)
:named kinding_Tm_arrow_98a6ce57193d862f12aa770d807de2d6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_98a6ce57193d862f12aa770d807de2d6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_98a6ce57193d862f12aa770d807de2d6))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_98a6ce57193d862f12aa770d807de2d6))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_98a6ce57193d862f12aa770d807de2d6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_98a6ce57193d862f12aa770d807de2d6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
@x1)
(HasType @x4
(Tm_arrow_1f559753133c819dcbab21eb87f04504 @x3
@x2)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(117,8-117,32)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x1))
(HasType @x3
@x1))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_98a6ce57193d862f12aa770d807de2d6))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_98a6ce57193d862f12aa770d807de2d6))
(declare-fun FStar.Classical.Sugar.exists_intro@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.exists_intro@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.exists_intro @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.exists_intro@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Classical.Sugar.exists_intro))

:named token_correspondence_FStar.Classical.Sugar.exists_intro))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.exists_intro@tok
Tm_arrow_98a6ce57193d862f12aa770d807de2d6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.exists_intro@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Classical.Sugar.exists_intro @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Classical.Sugar.exists_intro @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Classical.Sugar.exists_intro.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.exists_intro@tok))
:qid function_token_typing_FStar.Classical.Sugar.exists_intro))

:named function_token_typing_FStar.Classical.Sugar.exists_intro))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.exists_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(112,4-112,16)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_2eaa01e78f73e9bab5d0955fc1a662da @x0))
(HasType @x2
@x0)
(HasType @x3
(Tm_arrow_1f559753133c819dcbab21eb87f04504 @x2
@x1)))
(HasType (FStar.Classical.Sugar.exists_intro @x0
@x1
@x2
@x3)
(Tm_refine_df2d65c00128265e81a98d1694fa32db @x0
@x1)))
 

:pattern ((FStar.Classical.Sugar.exists_intro @x0
@x1
@x2
@x3))
:qid typing_FStar.Classical.Sugar.exists_intro))

:named typing_FStar.Classical.Sugar.exists_intro))

; </end encoding FStar.Classical.Sugar.exists_intro>


; <Start encoding FStar.Classical.Sugar.implies_intro>


;;;;;;;;;;;;;;;;_: Prims.squash p -> Prims.squash (q ())
(declare-fun Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226))

:named kinding_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x2
@x3)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(125,28-125,42)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(Prims.squash @x2))
(HasType (ApplyTT @x0
@x3)
(Prims.squash (ApplyTT @x1
Tm_unit))))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x1
@x2)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_8cc28639983f141a2c2b513a3b9f2226))
(declare-fun FStar.Classical.Sugar.implies_intro (Term Term Term) Term)


(declare-fun Tm_refine_210741fcd012f6981d2132fb47059ae4 (Term Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_refine_210741fcd012f6981d2132fb47059ae4 @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_refine_210741fcd012f6981d2132fb47059ae4 @x0
@x1)
Tm_type))
:qid refinement_kinding_Tm_refine_210741fcd012f6981d2132fb47059ae4))

:named refinement_kinding_Tm_refine_210741fcd012f6981d2132fb47059ae4))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_210741fcd012f6981d2132fb47059ae4 @x2
@x3))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27)
(implies 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(123,9-123,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,17-126,18)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(123,9-123,10); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,17-126,18)
@x2
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,23-126,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,23-126,26)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,23-126,26); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,23-126,26)
(ApplyTT @x3
Tm_unit)
)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_210741fcd012f6981d2132fb47059ae4 @x2
@x3)))
:qid refinement_interpretation_Tm_refine_210741fcd012f6981d2132fb47059ae4))

:named refinement_interpretation_Tm_refine_210741fcd012f6981d2132fb47059ae4))
;;;;;;;;;;;;;;;;haseq for Tm_refine_210741fcd012f6981d2132fb47059ae4
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,16-126,27)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_210741fcd012f6981d2132fb47059ae4 @x0
@x1)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_210741fcd012f6981d2132fb47059ae4 @x0
@x1))))
:qid haseqTm_refine_210741fcd012f6981d2132fb47059ae4))

:named haseqTm_refine_210741fcd012f6981d2132fb47059ae4))
;;;;;;;;;;;;;;;;p: Type -> q: (_: Prims.squash p -> Type) -> f: (_: Prims.squash p -> Prims.squash (q ()))   -> Prims.squash (p ==> q ())
(declare-fun Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5
Tm_type)
:named kinding_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(HasType @x3
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Tm_refine_210741fcd012f6981d2132fb47059ae4 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(126,8-126,28)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))
(declare-fun FStar.Classical.Sugar.implies_intro@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.implies_intro@tok
@x0)
@x1)
@x2)
(FStar.Classical.Sugar.implies_intro @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.implies_intro@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Classical.Sugar.implies_intro))

:named token_correspondence_FStar.Classical.Sugar.implies_intro))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.implies_intro@tok
Tm_arrow_16ed35ee40b45e5834d942fa129fc7a5))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.implies_intro@tok
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.implies_intro @x1
@x2
@x3))
 

:pattern ((FStar.Classical.Sugar.implies_intro @x1
@x2
@x3))
:qid function_token_typing_FStar.Classical.Sugar.implies_intro.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.implies_intro@tok))
:qid function_token_typing_FStar.Classical.Sugar.implies_intro))

:named function_token_typing_FStar.Classical.Sugar.implies_intro))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.implies_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(122,4-122,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x0))
(HasType @x2
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x1
@x0)))
(HasType (FStar.Classical.Sugar.implies_intro @x0
@x1
@x2)
(Tm_refine_210741fcd012f6981d2132fb47059ae4 @x0
@x1)))
 

:pattern ((FStar.Classical.Sugar.implies_intro @x0
@x1
@x2))
:qid typing_FStar.Classical.Sugar.implies_intro))

:named typing_FStar.Classical.Sugar.implies_intro))

; </end encoding FStar.Classical.Sugar.implies_intro>


; <Start encoding FStar.Classical.Sugar.or_intro_left>




(declare-fun FStar.Classical.Sugar.or_intro_left (Term Term Term) Term)




;;;;;;;;;;;;;;;;p: Type -> q: (_: Prims.squash (~p) -> Type) -> f: (_: Prims.unit -> Prims.squash p)   -> Prims.squash (p \/ q ())
(declare-fun Tm_arrow_ba201b0aaffa8c92349bb033309546c6 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_ba201b0aaffa8c92349bb033309546c6
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_left; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_ba201b0aaffa8c92349bb033309546c6
Tm_type)
:named kinding_Tm_arrow_ba201b0aaffa8c92349bb033309546c6))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_left; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_ba201b0aaffa8c92349bb033309546c6)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_ba201b0aaffa8c92349bb033309546c6))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_ba201b0aaffa8c92349bb033309546c6))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_ba201b0aaffa8c92349bb033309546c6))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_ba201b0aaffa8c92349bb033309546c6
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_left; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_ba201b0aaffa8c92349bb033309546c6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(HasType @x3
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Tm_refine_044452ce08fa2077b813992baef379a7 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_ba201b0aaffa8c92349bb033309546c6.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_ba201b0aaffa8c92349bb033309546c6.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(136,8-136,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_ba201b0aaffa8c92349bb033309546c6.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_ba201b0aaffa8c92349bb033309546c6))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_ba201b0aaffa8c92349bb033309546c6))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_ba201b0aaffa8c92349bb033309546c6))
(declare-fun FStar.Classical.Sugar.or_intro_left@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_left; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_intro_left@tok
@x0)
@x1)
@x2)
(FStar.Classical.Sugar.or_intro_left @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_intro_left@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Classical.Sugar.or_intro_left))

:named token_correspondence_FStar.Classical.Sugar.or_intro_left))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_left; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.or_intro_left@tok
Tm_arrow_ba201b0aaffa8c92349bb033309546c6))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_intro_left@tok
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.or_intro_left @x1
@x2
@x3))
 

:pattern ((FStar.Classical.Sugar.or_intro_left @x1
@x2
@x3))
:qid function_token_typing_FStar.Classical.Sugar.or_intro_left.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.or_intro_left@tok))
:qid function_token_typing_FStar.Classical.Sugar.or_intro_left))

:named function_token_typing_FStar.Classical.Sugar.or_intro_left))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_left; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(132,4-132,17)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x0))
(HasType @x2
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x0)))
(HasType (FStar.Classical.Sugar.or_intro_left @x0
@x1
@x2)
(Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1)))
 

:pattern ((FStar.Classical.Sugar.or_intro_left @x0
@x1
@x2))
:qid typing_FStar.Classical.Sugar.or_intro_left))

:named typing_FStar.Classical.Sugar.or_intro_left))

; </end encoding FStar.Classical.Sugar.or_intro_left>


; <Start encoding FStar.Classical.Sugar.or_intro_right>




;;;;;;;;;;;;;;;;_: Prims.squash (~p) -> Prims.squash (q ())
(declare-fun Tm_arrow_c1f46761cba190a64ceda9e0b423d73a (Term Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x0
@x1)
Tm_type)
 

:pattern ((HasType (Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x0
@x1)
Tm_type))
:qid kinding_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a))

:named kinding_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x2
@x3))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x2
@x3)))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x1
@x2))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(145,30-145,44)
(forall ((@x3 Term))
 (! (implies (HasType @x3
(Tm_refine_953a6e4e702e848a7213bd619baaa22d @x2))
(HasType (ApplyTT @x0
@x3)
(Prims.squash (ApplyTT @x1
Tm_unit))))
 

:pattern ((ApplyTT @x0
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x1
@x2)))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_c1f46761cba190a64ceda9e0b423d73a))
(declare-fun FStar.Classical.Sugar.or_intro_right (Term Term Term) Term)





;;;;;;;;;;;;;;;;p: Type -> q: (_: Prims.squash (~p) -> Type) -> f: (_: Prims.squash (~p) -> Prims.squash (q ()))   -> Prims.squash (p \/ q ())
(declare-fun Tm_arrow_820ce98d2bc904183444162411ef4873 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_820ce98d2bc904183444162411ef4873
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_820ce98d2bc904183444162411ef4873
Tm_type)
:named kinding_Tm_arrow_820ce98d2bc904183444162411ef4873))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_820ce98d2bc904183444162411ef4873)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_820ce98d2bc904183444162411ef4873))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_820ce98d2bc904183444162411ef4873))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_820ce98d2bc904183444162411ef4873))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_820ce98d2bc904183444162411ef4873
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_820ce98d2bc904183444162411ef4873)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1))
(HasType @x3
(Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
(Tm_refine_044452ce08fa2077b813992baef379a7 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_820ce98d2bc904183444162411ef4873.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_820ce98d2bc904183444162411ef4873.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(146,8-146,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_820ce98d2bc904183444162411ef4873.3))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_820ce98d2bc904183444162411ef4873))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_820ce98d2bc904183444162411ef4873))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_820ce98d2bc904183444162411ef4873))
(declare-fun FStar.Classical.Sugar.or_intro_right@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_intro_right@tok
@x0)
@x1)
@x2)
(FStar.Classical.Sugar.or_intro_right @x0
@x1
@x2))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_intro_right@tok
@x0)
@x1)
@x2))
:qid token_correspondence_FStar.Classical.Sugar.or_intro_right))

:named token_correspondence_FStar.Classical.Sugar.or_intro_right))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.or_intro_right@tok
Tm_arrow_820ce98d2bc904183444162411ef4873))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.or_intro_right@tok
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.or_intro_right @x1
@x2
@x3))
 

:pattern ((FStar.Classical.Sugar.or_intro_right @x1
@x2
@x3))
:qid function_token_typing_FStar.Classical.Sugar.or_intro_right.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.or_intro_right@tok))
:qid function_token_typing_FStar.Classical.Sugar.or_intro_right))

:named function_token_typing_FStar.Classical.Sugar.or_intro_right))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.or_intro_right; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(142,4-142,18)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_0e4b9f46020ce2f098f1971a515a22d9 @x0))
(HasType @x2
(Tm_arrow_c1f46761cba190a64ceda9e0b423d73a @x1
@x0)))
(HasType (FStar.Classical.Sugar.or_intro_right @x0
@x1
@x2)
(Tm_refine_044452ce08fa2077b813992baef379a7 @x0
@x1)))
 

:pattern ((FStar.Classical.Sugar.or_intro_right @x0
@x1
@x2))
:qid typing_FStar.Classical.Sugar.or_intro_right))

:named typing_FStar.Classical.Sugar.or_intro_right))

; </end encoding FStar.Classical.Sugar.or_intro_right>


; <Start encoding FStar.Classical.Sugar.and_intro>




(declare-fun FStar.Classical.Sugar.and_intro (Term Term Term Term) Term)




;;;;;;;;;;;;;;;;p: Type ->     q: (_: Prims.squash p -> Type) ->     left: (_: Prims.unit -> Prims.squash p) ->     right: (_: Prims.squash p -> Prims.squash (q ()))   -> Prims.squash (p /\ q ())
(declare-fun Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113
;;; Fact-ids: Name FStar.Classical.Sugar.and_intro; Namespace FStar.Classical.Sugar
(assert (! (HasType Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113
Tm_type)
:named kinding_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name FStar.Classical.Sugar.and_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))
:qid FStar.Classical.Sugar_pre_typing_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))

:named FStar.Classical.Sugar_pre_typing_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113
;;; Fact-ids: Name FStar.Classical.Sugar.and_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(HasType @x3
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x1))
(HasType @x4
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x2
@x1)))
(HasType (ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4)
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x1
@x2)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)
@x4))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_type)
(IsTotFun (ApplyTT @x0
@x1)))
 

:pattern ((ApplyTT @x0
@x1))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113.2))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27)
(forall ((@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1)))
(IsTotFun (ApplyTT (ApplyTT @x0
@x1)
@x2)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x1)
@x2))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113.3))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(157,8-157,27)
(forall ((@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x1
Tm_type)
(HasType @x2
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x1))
(HasType @x3
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x1)))
(IsTotFun (ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3)))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT @x0
@x1)
@x2)
@x3))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113.4))
))
 

:pattern ((HasTypeZ @x0
Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))
:qid FStar.Classical.Sugar_interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))

:named FStar.Classical.Sugar_interpretation_Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))
(declare-fun FStar.Classical.Sugar.and_intro@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name FStar.Classical.Sugar.and_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.and_intro@tok
@x0)
@x1)
@x2)
@x3)
(FStar.Classical.Sugar.and_intro @x0
@x1
@x2
@x3))
 

:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.and_intro@tok
@x0)
@x1)
@x2)
@x3))
:qid token_correspondence_FStar.Classical.Sugar.and_intro))

:named token_correspondence_FStar.Classical.Sugar.and_intro))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name FStar.Classical.Sugar.and_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType FStar.Classical.Sugar.and_intro@tok
Tm_arrow_74dd2a70fe5b8eefc42b899233f1e113))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13)
(forall ((@x1 Term) (@x2 Term) (@x3 Term) (@x4 Term))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT FStar.Classical.Sugar.and_intro@tok
@x1)
@x2)
@x3)
@x4)
(FStar.Classical.Sugar.and_intro @x1
@x2
@x3
@x4))
 

:pattern ((FStar.Classical.Sugar.and_intro @x1
@x2
@x3
@x4))
:qid function_token_typing_FStar.Classical.Sugar.and_intro.1))
)
 

:pattern ((ApplyTT @x0
FStar.Classical.Sugar.and_intro@tok))
:qid function_token_typing_FStar.Classical.Sugar.and_intro))

:named function_token_typing_FStar.Classical.Sugar.and_intro))

;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name FStar.Classical.Sugar.and_intro; Namespace FStar.Classical.Sugar
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(152,4-152,13)
(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x0
Tm_type)
(HasType @x1
(Tm_arrow_e617226e5c485cfca90836a8d37dc422 @x0))
(HasType @x2
(Tm_arrow_e5bf96e6b202d44baf035cb07df2da84 @x0))
(HasType @x3
(Tm_arrow_8cc28639983f141a2c2b513a3b9f2226 @x1
@x0)))
(HasType (FStar.Classical.Sugar.and_intro @x0
@x1
@x2
@x3)
(Tm_refine_0e6764ea7cf9747bf338120e46774802 @x0
@x1)))
 

:pattern ((FStar.Classical.Sugar.and_intro @x0
@x1
@x2
@x3))
:qid typing_FStar.Classical.Sugar.and_intro))

:named typing_FStar.Classical.Sugar.and_intro))

; </end encoding FStar.Classical.Sugar.and_intro>


; End Externals for interface FStar.Classical.Sugar

;;; End interface FStar.Classical.Sugar (256 decls; total size 134096)

; Internals for Alex

(push)

; encoding sigelt unbounded


; <Start encoding Alex.unbounded>

;;;;;;;;;;;;;;;;_: Prims.nat -> Prims.int
(declare-fun Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! (HasType Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb
Tm_type)
:named kinding_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,25-3,28); use=Alex.fst(3,25-3,28)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))
:qid Alex_pre_typing_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))

:named Alex_pre_typing_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,25-3,28); use=Alex.fst(3,25-3,28)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb)
(and 
;; def=Alex.fst(3,25-3,28); use=Alex.fst(3,25-3,28)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.nat)
(HasType (ApplyTT @x0
@x1)
Prims.int))
 

:pattern ((ApplyTT @x0
@x1))
:qid Alex_interpretation_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))
:qid Alex_interpretation_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))

:named Alex_interpretation_Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))
(declare-fun Alex.unbounded (Term) Term)

;;;;;;;;;;;;;;;;f: (_: Prims.nat -> Prims.int) -> Prims.logical
(declare-fun Tm_arrow_720fb0f945ffbc2c18f0f46892831757 () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_720fb0f945ffbc2c18f0f46892831757
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! (HasType Tm_arrow_720fb0f945ffbc2c18f0f46892831757
Tm_type)
:named kinding_Tm_arrow_720fb0f945ffbc2c18f0f46892831757))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=Alex.fst(3,39-3,47)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_720fb0f945ffbc2c18f0f46892831757)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_720fb0f945ffbc2c18f0f46892831757))
:qid Alex_pre_typing_Tm_arrow_720fb0f945ffbc2c18f0f46892831757))

:named Alex_pre_typing_Tm_arrow_720fb0f945ffbc2c18f0f46892831757))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_720fb0f945ffbc2c18f0f46892831757
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=Alex.fst(3,39-3,47)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_720fb0f945ffbc2c18f0f46892831757)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(265,50-265,57); use=Alex.fst(3,39-3,47)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb)
(HasType (ApplyTT @x0
@x1)
Prims.logical))
 

:pattern ((ApplyTT @x0
@x1))
:qid Alex_interpretation_Tm_arrow_720fb0f945ffbc2c18f0f46892831757.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_720fb0f945ffbc2c18f0f46892831757))
:qid Alex_interpretation_Tm_arrow_720fb0f945ffbc2c18f0f46892831757))

:named Alex_interpretation_Tm_arrow_720fb0f945ffbc2c18f0f46892831757))
(declare-fun Alex.unbounded@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,4-3,13); use=Alex.fst(3,4-3,13)
(forall ((@x0 Term))
 (! (= (ApplyTT Alex.unbounded@tok
@x0)
(Alex.unbounded @x0))
 

:pattern ((ApplyTT Alex.unbounded@tok
@x0))
:qid token_correspondence_Alex.unbounded))

:named token_correspondence_Alex.unbounded))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,4-3,13); use=Alex.fst(3,4-3,13)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Alex.unbounded@tok
Tm_arrow_720fb0f945ffbc2c18f0f46892831757))

;; def=Alex.fst(3,4-3,13); use=Alex.fst(3,4-3,13)
(forall ((@x1 Term))
 (! (= (ApplyTT Alex.unbounded@tok
@x1)
(Alex.unbounded @x1))
 

:pattern ((Alex.unbounded @x1))
:qid function_token_typing_Alex.unbounded.1))
)
 

:pattern ((ApplyTT @x0
Alex.unbounded@tok))
:qid function_token_typing_Alex.unbounded))

:named function_token_typing_Alex.unbounded))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,4-3,13); use=Alex.fst(3,4-3,13)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb)
(HasType (Alex.unbounded @x0)
Prims.logical))
 

:pattern ((Alex.unbounded @x0))
:qid typing_Alex.unbounded))

:named typing_Alex.unbounded))

;;;;;;;;;;;;;;;;n: Prims.nat -> Prims.GTot Type
(declare-fun Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e () Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! (HasType Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e
Tm_type)
:named kinding_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,40-496,45); use=Alex.fst(3,56-3,63)
(forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel @u0
@x1
Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e)
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))
:qid Alex_pre_typing_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))

:named Alex_pre_typing_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,40-496,45); use=Alex.fst(3,56-3,63)
(forall ((@x0 Term))
 (! (iff (HasTypeZ @x0
Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(496,40-496,45); use=Alex.fst(3,56-3,63)
(forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.nat)
(HasType (ApplyTT @x0
@x1)
Tm_type))
 

:pattern ((ApplyTT @x0
@x1))
:qid Alex_interpretation_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e.1))

(IsTotFun @x0)))
 

:pattern ((HasTypeZ @x0
Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))
:qid Alex_interpretation_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))

:named Alex_interpretation_Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e))
(declare-fun Tm_abs_d8b206863e16ee6116475ebcb09eeb0b (Term Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_d8b206863e16ee6116475ebcb09eeb0b
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,49-3,78); use=Alex.fst(3,49-3,78)
(forall ((@x0 Term) (@x1 Term))
 (! (HasType (Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x0
@x1)
Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e)
 

:pattern ((Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x0
@x1))
:qid typing_Tm_abs_d8b206863e16ee6116475ebcb09eeb0b))

:named typing_Tm_abs_d8b206863e16ee6116475ebcb09eeb0b))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_d8b206863e16ee6116475ebcb09eeb0b
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,49-3,78); use=Alex.fst(3,49-3,78)
(forall ((@x0 Term) (@x1 Term) (@x2 Term))
 (! (= (ApplyTT (Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x1
@x2)
@x0)
(Prims.b2t (Prims.op_GreaterThan (Prims.abs (ApplyTT @x1
@x0))
@x2)))
 

:pattern ((ApplyTT (Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x1
@x2)
@x0))
:qid interpretation_Tm_abs_d8b206863e16ee6116475ebcb09eeb0b))

:named interpretation_Tm_abs_d8b206863e16ee6116475ebcb09eeb0b))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
;; def=Alex.fst(3,49-3,78); use=Alex.fst(3,49-3,78)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (Valid (Prims.l_Exists Prims.nat
(Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x1
@x0)))

;; def=Alex.fst(3,49-3,78); use=Alex.fst(3,49-3,78)
(exists ((@x2 Term))
 (! (and (HasType @x2
Prims.nat)

;; def=Alex.fst(3,65-3,78); use=Alex.fst(3,65-3,78)
(> (BoxInt_proj_0 (Prims.abs (ApplyTT @x1
@x2)))
(BoxInt_proj_0 @x0))
)
 
;;no pats
:qid l_quant_interp_e6a33c0034349ccda8a84f4325e54be6.1))
)
 

:pattern ((Valid (Prims.l_Exists Prims.nat
(Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x1
@x0))))
:qid l_quant_interp_e6a33c0034349ccda8a84f4325e54be6))

:named l_quant_interp_e6a33c0034349ccda8a84f4325e54be6))

(declare-fun Tm_abs_e60f7c202c1ef6372acae5dc662458e7 (Term) Term)
;;;;;;;;;;;;;;;;typing_Tm_abs_e60f7c202c1ef6372acae5dc662458e7
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
         ;; def=Alex.fst(3,32-3,78); use=Alex.fst(3,32-3,78)
         (forall ((@x0 Term))
                 (! (HasType (Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x0)
                             Tm_arrow_9974df5c311cfcfa7100bc7bef095e1e)
                    

                    :pattern ((Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x0))
                    :qid typing_Tm_abs_e60f7c202c1ef6372acae5dc662458e7))

         :named typing_Tm_abs_e60f7c202c1ef6372acae5dc662458e7))
;;;;;;;;;;;;;;;;interpretation_Tm_abs_e60f7c202c1ef6372acae5dc662458e7
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
         ;; def=Alex.fst(3,32-3,78); use=Alex.fst(3,32-3,78)
         (forall ((@x0 Term) (@x1 Term))
                 (! (= (ApplyTT (Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x1)
                                @x0)
                       (Prims.l_Exists Prims.nat
                                       (Tm_abs_d8b206863e16ee6116475ebcb09eeb0b @x1
                                                                                @x0)))
                    

                    :pattern ((ApplyTT (Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x1)
                                       @x0))
                    :qid interpretation_Tm_abs_e60f7c202c1ef6372acae5dc662458e7))

         :named interpretation_Tm_abs_e60f7c202c1ef6372acae5dc662458e7))
;;;;;;;;;;;;;;;;Interpretation of deeply embedded quantifier
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
         ;; def=Alex.fst(3,32-3,78); use=Alex.fst(3,32-3,78)
         (forall ((@x0 Term))
                 (! (iff (Valid (Prims.l_Forall Prims.nat
                                                (Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x0)))

                         ;; def=Alex.fst(3,32-3,78); use=Alex.fst(3,32-3,78)
                         (forall ((@x1 Term))
                                 (! (implies (HasType @x1
                                                      Prims.nat)

                                             ;; def=Alex.fst(3,49-3,78); use=Alex.fst(3,49-3,78)
                                             (exists ((@x2 Term))
                                                     (! (and (HasType @x2
                                                                      Prims.nat)

                                                             ;; def=Alex.fst(3,65-3,78); use=Alex.fst(3,65-3,78)
                                                             (> (BoxInt_proj_0 (Prims.abs (ApplyTT @x0
                                                                                                   @x2)))
                                                                (BoxInt_proj_0 @x1))
                                                             )
                                                        
                                                        ;;no pats
                                                        :qid l_quant_interp_0e9c6b5b9967880f892e1f4bd5722ce0.2))
                                             )
                                    
                                    ;;no pats
                                    :qid l_quant_interp_0e9c6b5b9967880f892e1f4bd5722ce0.1))
                         )
                    

                    :pattern ((Valid (Prims.l_Forall Prims.nat
                                                     (Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x0))))
                    :qid l_quant_interp_0e9c6b5b9967880f892e1f4bd5722ce0))

         :named l_quant_interp_0e9c6b5b9967880f892e1f4bd5722ce0))
;;;;;;;;;;;;;;;;Equation for Alex.unbounded
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
         ;; def=Alex.fst(3,4-3,13); use=Alex.fst(3,4-3,13)
         (forall ((@x0 Term))
                 (! (= (Valid (Alex.unbounded @x0))

                       ;; def=Alex.fst(3,32-3,78); use=Alex.fst(3,32-3,78)
                       (forall ((@x1 Term))
                               (! (implies (HasType @x1
                                                    Prims.nat)

                                           ;; def=Alex.fst(3,49-3,78); use=Alex.fst(3,49-3,78)
                                           (exists ((@x2 Term))
                                                   (! (and (HasType @x2
                                                                    Prims.nat)

                                                           ;; def=Alex.fst(3,65-3,78); use=Alex.fst(3,65-3,78)
                                                           (> (BoxInt_proj_0 (Prims.abs (ApplyTT @x0
                                                                                                 @x2)))
                                                              (BoxInt_proj_0 @x1))
                                                           )
                                                      
                                                      ;;no pats
                                                      :qid equation_Alex.unbounded.2))
                                           )
                                  
                                  ;;no pats
                                  :qid equation_Alex.unbounded.1))
                       )
                    

                    :pattern ((Alex.unbounded @x0))
                    :qid equation_Alex.unbounded))

         :named equation_Alex.unbounded))
;;;;;;;;;;;;;;;;Equation for Alex.unbounded
;;; Fact-ids: Name Alex.unbounded; Namespace Alex
(assert (! 
         ;; def=Alex.fst(3,4-3,13); use=Alex.fst(3,4-3,13)
         (forall ((@x0 Term))
                 (! (= (Alex.unbounded @x0)
                       (Prims.l_Forall Prims.nat
                                       (Tm_abs_e60f7c202c1ef6372acae5dc662458e7 @x0)))
                    

                    :pattern ((Prims.subtype_of (Alex.unbounded @x0)
                                                Prims.unit))
                    :qid defn_equation_Alex.unbounded))

         :named defn_equation_Alex.unbounded))

; </end encoding Alex.unbounded>


; encoding sigelt f


; <Start encoding Alex.f>

(declare-fun Alex.f (Term) Term)

(declare-fun Tm_refine_4a238e1e06eccc65deba555c9a504c92 () Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: Name Alex.f; Namespace Alex
(assert (! (HasType Tm_refine_4a238e1e06eccc65deba555c9a504c92
Tm_type)
:named refinement_kinding_Tm_refine_4a238e1e06eccc65deba555c9a504c92))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: Name Alex.f; Namespace Alex
(assert (! 
;; def=Alex.fst(4,15-4,44); use=Alex.fst(4,15-4,44)
(forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasTypeFuel @u0
@x1
Tm_refine_4a238e1e06eccc65deba555c9a504c92)
(and (HasTypeFuel @u0
@x1
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb)

;; def=Alex.fst(4,31-4,42); use=Alex.fst(4,31-4,42)
(Valid 
;; def=Alex.fst(4,31-4,42); use=Alex.fst(4,31-4,42)
(Alex.unbounded @x1)
)
))
 

:pattern ((HasTypeFuel @u0
@x1
Tm_refine_4a238e1e06eccc65deba555c9a504c92))
:qid refinement_interpretation_Tm_refine_4a238e1e06eccc65deba555c9a504c92))

:named refinement_interpretation_Tm_refine_4a238e1e06eccc65deba555c9a504c92))
;;;;;;;;;;;;;;;;haseq for Tm_refine_4a238e1e06eccc65deba555c9a504c92
;;; Fact-ids: Name Alex.f; Namespace Alex
(assert (! (iff (Valid (Prims.hasEq Tm_refine_4a238e1e06eccc65deba555c9a504c92))
(Valid (Prims.hasEq Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb)))
:named haseqTm_refine_4a238e1e06eccc65deba555c9a504c92))
(declare-fun Alex.f@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Alex.f; Namespace Alex
(assert (! 
;; def=Alex.fst(4,11-4,12); use=Alex.fst(4,11-4,12)
(forall ((@x0 Term))
 (! (= (ApplyTT Alex.f@tok
@x0)
(Alex.f @x0))
 

:pattern ((ApplyTT Alex.f@tok
@x0))
:qid token_correspondence_Alex.f))

:named token_correspondence_Alex.f))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Alex.f; Namespace Alex
(assert (! 
;; def=Alex.fst(4,11-4,12); use=Alex.fst(4,11-4,12)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Alex.f@tok
Tm_refine_4a238e1e06eccc65deba555c9a504c92))

;; def=Alex.fst(4,11-4,12); use=Alex.fst(4,11-4,12)
(forall ((@x1 Term))
 (! (= (ApplyTT Alex.f@tok
@x1)
(Alex.f @x1))
 

:pattern ((Alex.f @x1))
:qid function_token_typing_Alex.f.1))
)
 

:pattern ((ApplyTT @x0
Alex.f@tok))
:qid function_token_typing_Alex.f))

:named function_token_typing_Alex.f))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Alex.f; Namespace Alex
(assert (! 
;; def=Alex.fst(4,11-4,12); use=Alex.fst(4,11-4,12)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.nat)
(HasType (Alex.f @x0)
Prims.int))
 

:pattern ((Alex.f @x0))
:qid typing_Alex.f))

:named typing_Alex.f))

; </end encoding Alex.f>


; encoding sigelt g


; <Start encoding Alex.g>

(declare-fun Alex.g (Term) Term)

(declare-fun Alex.g@tok () Term)
;;;;;;;;;;;;;;;;Name-token correspondence
;;; Fact-ids: Name Alex.g; Namespace Alex
(assert (! 
;; def=Alex.fst(6,4-6,5); use=Alex.fst(6,4-6,5)
(forall ((@x0 Term))
 (! (= (ApplyTT Alex.g@tok
@x0)
(Alex.g @x0))
 

:pattern ((ApplyTT Alex.g@tok
@x0))
:qid token_correspondence_Alex.g))

:named token_correspondence_Alex.g))
;;;;;;;;;;;;;;;;function token typing
;;; Fact-ids: Name Alex.g; Namespace Alex
(assert (! 
;; def=Alex.fst(6,4-6,5); use=Alex.fst(6,4-6,5)
(forall ((@x0 Term))
 (! (and (NoHoist @x0
(HasType Alex.g@tok
Tm_arrow_fc34ca66de2f262c06145b17fb7ed6cb))

;; def=Alex.fst(6,4-6,5); use=Alex.fst(6,4-6,5)
(forall ((@x1 Term))
 (! (= (ApplyTT Alex.g@tok
@x1)
(Alex.g @x1))
 

:pattern ((Alex.g @x1))
:qid function_token_typing_Alex.g.1))
)
 

:pattern ((ApplyTT @x0
Alex.g@tok))
:qid function_token_typing_Alex.g))

:named function_token_typing_Alex.g))
;;;;;;;;;;;;;;;;free var typing
;;; Fact-ids: Name Alex.g; Namespace Alex
(assert (! 
;; def=Alex.fst(6,4-6,5); use=Alex.fst(6,4-6,5)
(forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.nat)
(HasType (Alex.g @x0)
Prims.int))
 

:pattern ((Alex.g @x0))
:qid typing_Alex.g))

:named typing_Alex.g))
;;;;;;;;;;;;;;;;Equation for Alex.g
;;; Fact-ids: Name Alex.g; Namespace Alex
(assert (! 
;; def=Alex.fst(6,4-6,5); use=Alex.fst(6,4-6,5)
(forall ((@x0 Term))
 (! (= (Alex.g @x0)
(Alex.f (Prims.op_Addition @x0
(BoxInt 1))))
 

:pattern ((Alex.g @x0))
:qid equation_Alex.g))

:named equation_Alex.g))

; </end encoding Alex.g>


; encoding sigelt 


; <Skipped />


; encoding sigelt 


; <Skipped />

(push)

; Starting query at Alex.fst(11,2-23,5)

(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)
;;;;;;;;;;;;;;;;kick_partial_app
;;; Fact-ids: 
(assert (! (Valid (ApplyTT __uu__PartialApp
Alex.f@tok))
:named @kick_partial_app_be89ab15077069bb7f7d25c22b56aaa8))
(declare-fun Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 (Term) Term)
;;;;;;;;;;;;;;;;refinement kinding
;;; Fact-ids: 
(assert (! 
;; def=Alex.fst(14,10-14,39); use=Alex.fst(11,2-23,5)
(forall ((@x0 Term))
 (! (HasType (Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x0)
Tm_type)
 

:pattern ((HasType (Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x0)
Tm_type))
:qid refinement_kinding_Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02))

:named refinement_kinding_Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02))
;;;;;;;;;;;;;;;;refinement_interpretation
;;; Fact-ids: 
(assert (! 
;; def=Alex.fst(14,10-14,39); use=Alex.fst(11,2-23,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasTypeFuel @u0
@x1
(Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x2))
(and (HasTypeFuel @u0
@x1
Prims.unit)

;; def=Alex.fst(14,10-14,39); use=Alex.fst(11,2-23,5)
(exists ((@x3 Term))
 (! (and (HasType @x3
Prims.nat)

;; def=Alex.fst(14,26-14,39); use=Alex.fst(11,2-23,5)
(> (BoxInt_proj_0 (Prims.abs (Alex.g @x3)))
(BoxInt_proj_0 @x2))
)
 
;;no pats
:qid refinement_interpretation_Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02.1))
))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x2)))
:qid refinement_interpretation_Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02))

:named refinement_interpretation_Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02))
;;;;;;;;;;;;;;;;haseq for Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02
;;; Fact-ids: 
(assert (! 
;; def=Alex.fst(14,10-14,39); use=Alex.fst(11,2-23,5)
(forall ((@x0 Term))
 (! (iff (Valid (Prims.hasEq (Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x0)))
(Valid (Prims.hasEq Prims.unit)))
 

:pattern ((Valid (Prims.hasEq (Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x0))))
:qid haseqTm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02))

:named haseqTm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02))
;;;;;;;;;;;;;;;;x: Prims.nat -> _: Prims.squash (Prims.abs (Alex.f x) > m)   -> Prims.squash (exists (i: Prims.nat). Prims.abs (Alex.g i) > m)
(declare-fun Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 (Term) Term)
;;;;;;;;;;;;;;;;kinding_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0
;;; Fact-ids: 
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=Alex.fst(11,2-23,5)
(forall ((@x0 Term))
 (! (HasType (Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x0)
Tm_type)
 

:pattern ((HasType (Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x0)
Tm_type))
:qid kinding_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0))

:named kinding_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0))
;;;;;;;;;;;;;;;;pre-typing for functions
;;; Fact-ids: 
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=Alex.fst(11,2-23,5)
(forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel @u0
@x1
(Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x2))
(is-Tm_arrow (PreType @x1)))
 

:pattern ((HasTypeFuel @u0
@x1
(Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x2)))
:qid Alex_pre_typing_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0))

:named Alex_pre_typing_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0))
;;;;;;;;;;;;;;;;interpretation_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0
;;; Fact-ids: 
(assert (! 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=Alex.fst(11,2-23,5)
(forall ((@x0 Term) (@x1 Term))
 (! (iff (HasTypeZ @x0
(Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x1))
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=Alex.fst(11,2-23,5)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Prims.nat)
(HasType @x3
(Prims.squash (Prims.b2t (Prims.op_GreaterThan (Prims.abs (Alex.f @x2))
@x1)))))
(HasType (ApplyTT (ApplyTT @x0
@x2)
@x3)
(Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x1)))
 

:pattern ((ApplyTT (ApplyTT @x0
@x2)
@x3))
:qid Alex_interpretation_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0.1))

(IsTotFun @x0)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(67,37-67,47); use=Alex.fst(11,2-23,5)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Prims.nat)
(IsTotFun (ApplyTT @x0
@x2)))
 

:pattern ((ApplyTT @x0
@x2))
:qid Alex_interpretation_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0.2))
))
 

:pattern ((HasTypeZ @x0
(Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x1)))
:qid Alex_interpretation_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0))

:named Alex_interpretation_Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0))




; Encoding query formula : forall (m: Prims.nat).
;   (*could not prove post-condition*)
;   forall (p: Prims.pure_post Prims.unit).
;     (forall (pure_result: Prims.unit).
;         (exists (i: Prims.nat). Prims.abs (Alex.g i) > m) ==> p pure_result) ==>
;     Alex.unbounded Alex.f /\
;     (forall (pure_result: Prims.unit).
;         Alex.unbounded Alex.f ==>
;         (forall (m: Prims.nat) (n: Prims.nat). Prims.abs (Alex.f n) > m) /\
;         (forall (pure_result: Prims.unit).
;             (forall (m: Prims.nat) (n: Prims.nat). Prims.abs (Alex.f n) > m) ==>
;             (forall (_: Prims.unit) (x: Prims.nat). Prims.abs (Alex.f x) > m) /\
;             (forall (any_result: Prims.unit).
;                 (forall (j: Prims.nat) (_: Prims.squash (Prims.abs (Alex.f j) > m)).
;                     (*could not prove post-condition*)
;                     forall (k: Prims.pure_post Prims.unit).
;                       (forall (x: Prims.unit). {:pattern Prims.guard_free (k x)}
;                           (exists (i: Prims.nat). Prims.abs (Alex.g i) > m) ==> k x) ==>
;                       j > 0 == true ==>
;                       j - 1 >= 0 /\
;                       (forall (return_val: Prims.nat).
;                           return_val == j - 1 ==>
;                           (forall (any_result: Prims.int).
;                               Alex.g (j - 1) == any_result ==>
;                               (forall (any_result: Prims.logical).
;                                   Alex.g (j - 1) == Alex.f j == any_result ==>
;                                   Alex.g (j - 1) == Alex.f j)))) /\
;                 (forall (any_result:
;                     (x: Prims.nat -> _: Prims.squash (Prims.abs (Alex.f x) > m)
;                         -> Prims.squash (exists (i: Prims.nat). Prims.abs (Alex.g i) > m)))
;                     (any_result: Prims.squash (exists (i: Prims.nat). Prims.abs (Alex.g i) > m))
;                     (any_result: Prims.squash (exists (i: Prims.nat). Prims.abs (Alex.g i) > m)).
;                     p any_result))))

(push)

; <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.nat)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(393,51-393,91); use=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(417,19-417,32)
(forall ((@x1 Term))
 (! (implies (and (HasType @x1
(Prims.pure_post Prims.unit))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,36-428,97); use=Alex.fst(11,2-23,5)
(forall ((@x2 Term))
 (! (implies (and (or label_2
(HasType @x2
Prims.unit))

;; def=Alex.fst(10,33-10,64); use=Alex.fst(11,2-23,5)
(or label_3

;; def=Alex.fst(10,33-10,64); use=Alex.fst(11,2-23,5)
(exists ((@x3 Term))
 (! (and (HasType @x3
Prims.nat)

;; def=Alex.fst(10,50-10,63); use=Alex.fst(11,2-23,5)
(> (BoxInt_proj_0 (Prims.abs (Alex.g @x3)))
(BoxInt_proj_0 @x0))
)
 
;;no pats
:qid @query.3))
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,83-428,96); use=Alex.fst(11,2-23,5)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,83-428,96); use=Alex.fst(11,2-23,5)
(ApplyTT @x1
@x2)
)
)
 

:pattern (
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,83-428,96); use=Alex.fst(11,2-23,5)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,83-428,96); use=Alex.fst(11,2-23,5)
(ApplyTT @x1
@x2)
)
)
:qid @query.2))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,29-428,97); use=Alex.fst(11,2-11,8)
(and 
;; def=Alex.fst(11,9-11,22); use=Alex.fst(11,2-11,8)
(or label_4

;; def=Alex.fst(11,9-11,22); use=Alex.fst(11,2-11,8)
(Valid 
;; def=Alex.fst(11,9-11,22); use=Alex.fst(11,2-11,8)
(Alex.unbounded Alex.f@tok)
)
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,36-428,97); use=Alex.fst(11,2-11,8)
(forall ((@x2 Term))
 (! (implies (and (HasType @x2
Prims.unit)

;; def=Alex.fst(11,9-11,22); use=Alex.fst(11,2-11,8)
(Valid 
;; def=Alex.fst(11,9-11,22); use=Alex.fst(11,2-11,8)
(Alex.unbounded Alex.f@tok)
)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,29-428,97); use=Alex.fst(12,2-12,8)
(and 
;; def=Alex.fst(12,9-12,57); use=Alex.fst(12,2-12,8)
(forall ((@x3 Term))
 (! (implies (HasType @x3
Prims.nat)

;; def=Alex.fst(12,27-12,56); use=Alex.fst(12,2-12,8)
(or label_5

;; def=Alex.fst(12,27-12,56); use=Alex.fst(12,2-12,8)
(exists ((@x4 Term))
 (! (and (HasType @x4
Prims.nat)

;; def=Alex.fst(12,43-12,56); use=Alex.fst(12,2-12,8)
(> (BoxInt_proj_0 (Prims.abs (Alex.f @x4)))
(BoxInt_proj_0 @x3))
)
 
;;no pats
:qid @query.6))
)
)
 
;;no pats
:qid @query.5))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(428,36-428,97); use=Alex.fst(12,2-12,8)
(forall ((@x3 Term))
 (! (implies (and (HasType @x3
Prims.unit)

;; def=Alex.fst(12,9-12,57); use=Alex.fst(12,2-12,8)
(forall ((@x4 Term))
 (! (implies (HasType @x4
Prims.nat)

;; def=Alex.fst(12,27-12,56); use=Alex.fst(12,2-12,8)
(exists ((@x5 Term))
 (! (and (HasType @x5
Prims.nat)

;; def=Alex.fst(12,43-12,56); use=Alex.fst(12,2-12,8)
(> (BoxInt_proj_0 (Prims.abs (Alex.f @x5)))
(BoxInt_proj_0 @x4))
)
 
;;no pats
:qid @query.9))
)
 
;;no pats
:qid @query.8))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,77-446,89); use=Alex.fst(11,2-23,5)
(and 
;; def= dummy(0,0-0,0); use=Alex.fst(13,20-13,21)
(forall ((@x4 Term))
 (! (implies (HasType @x4
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41); use=Alex.fst(13,20-13,21)
(or label_6

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\FStar.Classical.Sugar.fsti(66,22-66,41); use=Alex.fst(13,20-13,21)
(exists ((@x5 Term))
 (! (and (HasType @x5
Prims.nat)

;; def=Alex.fst(13,28-13,41); use=Alex.fst(13,20-13,21)
(> (BoxInt_proj_0 (Prims.abs (Alex.f @x5)))
(BoxInt_proj_0 @x0))
)
 
;;no pats
:qid @query.11))
)
)
 
;;no pats
:qid @query.10))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=Alex.fst(11,2-23,5)
(forall ((@x4 Term))
 (! (implies (HasType @x4
Prims.unit)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,77-446,89); use=Alex.fst(11,2-23,5)
(and 
;; def= dummy(0,0-0,0); use=Alex.fst(11,2-23,5)
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
Prims.nat)
(HasType @x6
(Prims.squash (Prims.b2t (Prims.op_GreaterThan (Prims.abs (Alex.f @x5))
@x0)))))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=Alex.fst(16,4-22,6)
(forall ((@x7 Term))
 (! (implies (and (HasType @x7
(Prims.pure_post Prims.unit))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,2-389,97); use=Alex.fst(16,4-22,6)
(forall ((@x8 Term))
 (! (implies 
;; def=Alex.fst(14,10-14,39); use=Alex.fst(22,4-22,6)
(or label_7

;; def=Alex.fst(14,10-14,39); use=Alex.fst(22,4-22,6)
(exists ((@x9 Term))
 (! (and (HasType @x9
Prims.nat)

;; def=Alex.fst(14,26-14,39); use=Alex.fst(22,4-22,6)
(> (BoxInt_proj_0 (Prims.abs (Alex.g @x9)))
(BoxInt_proj_0 @x0))
)
 
;;no pats
:qid @query.16))
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,84-389,87); use=Alex.fst(16,4-22,6)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(389,84-389,87); use=Alex.fst(16,4-22,6)
(ApplyTT @x7
@x8)
)
)
 :weight 0


:pattern ((ApplyTT @x7
@x8))
:qid @query.15))


;; def=Alex.fst(16,7-16,14); use=Alex.fst(16,7-16,14)
(= (Prims.op_GreaterThan @x5
(BoxInt 0))
(BoxBool true))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(446,77-446,89); use=Alex.fst(16,4-22,6)
(and 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(675,18-675,24); use=Alex.fst(17,16-17,21)
(or label_8

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(675,18-675,24); use=Alex.fst(17,16-17,21)
(>= (BoxInt_proj_0 (Prims.op_Subtraction @x5
(BoxInt 1)))
(BoxInt_proj_0 (BoxInt 0)))
)


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,2-343,58); use=Alex.fst(16,4-22,6)
(forall ((@x8 Term))
 (! (implies (and (HasType @x8
Prims.nat)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(343,26-343,41); use=Alex.fst(16,4-22,6)
(= @x8
(Prims.op_Subtraction @x5
(BoxInt 1)))
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=Alex.fst(16,4-22,6)
(forall ((@x9 Term))
 (! (implies (and (HasType @x9
Prims.int)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(154,21-154,22); use=Alex.fst(16,4-22,6)
(= (Alex.g (Prims.op_Subtraction @x5
(BoxInt 1)))
@x9)
)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=Alex.fst(16,4-22,6)
(forall ((@x10 Term))
 (! (implies (and (HasType @x10
Prims.logical)

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(667,13-667,14); use=Alex.fst(16,4-22,6)
(= (Prims.eq2 Prims.int
(Alex.g (Prims.op_Subtraction @x5
(BoxInt 1)))
(Alex.f @x5))
@x10)
)

;; def=Alex.fst(17,13-17,29); use=Alex.fst(17,6-17,12)
(or label_9

;; def=Alex.fst(17,13-17,29); use=Alex.fst(17,6-17,12)
(= (Alex.g (Prims.op_Subtraction @x5
(BoxInt 1)))
(Alex.f @x5))
)
)
 
;;no pats
:qid @query.19))
)
 
;;no pats
:qid @query.18))
)
 
;;no pats
:qid @query.17))
)
)
 
;;no pats
:qid @query.14))
)
 
;;no pats
:qid @query.13))


;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=Alex.fst(11,2-23,5)
(forall ((@x5 Term))
 (! (implies (HasType @x5
(Tm_arrow_7fcba8b2e97aa7d271d0470df3910ea0 @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=Alex.fst(11,2-23,5)
(forall ((@x6 Term))
 (! (implies (HasType @x6
(Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,66-438,102); use=Alex.fst(11,2-23,5)
(forall ((@x7 Term))
 (! (implies (HasType @x7
(Tm_refine_8a82f3e93a1f1af98ddbbd4ccb78ba02 @x0))

;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,90-438,102); use=Alex.fst(11,2-23,5)
(Valid 
;; def=C:\cygwin64\home\nswamy\workspace\clean\FStar\ulib\prims.fst(438,90-438,102); use=Alex.fst(11,2-23,5)
(ApplyTT @x1
@x7)
)
)
 
;;no pats
:qid @query.22))
)
 
;;no pats
:qid @query.21))
)
 
;;no pats
:qid @query.20))
)
)
 
;;no pats
:qid @query.12))
)
)
 
;;no pats
:qid @query.7))
)
)
 
;;no pats
:qid @query.4))
)
)
 
;;no pats
:qid @query.1))
)
 
;;no pats
:qid @query)))
:named @query))
(set-option :rlimit 272328)
(echo "<result>")
(check-sat)
(echo "</result>")
(set-option :rlimit 0)
(echo "<reason-unknown>")
(get-info :reason-unknown)
(echo "</reason-unknown>")
(echo "<unsat-core>")
(get-unsat-core)
(echo "</unsat-core>")
(echo "<statistics>")
(get-info :all-statistics)
(echo "</statistics>")
(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 "</labels>")
(echo "Done!")
(pop)

; Ending query at Alex.fst(11,2-23,5)

(pop)