Query file that causes Z3 to fail

plouf2-fail.smt2

(set-option :global-decls false)
(set-option :smt.mbqi false)
(set-option :smt.qi.profile true)
(declare-sort Ref)
(declare-fun Ref_constr_id (Ref) Int)

(declare-sort String)
(declare-fun String_constr_id (String) Int)

(declare-sort Kind)
(declare-fun Kind_constr_id (Kind) Int)

(declare-sort Type)
(declare-fun Type_constr_id (Type) Int)

(declare-sort Term)
(declare-fun Term_constr_id (Term) Int)
(declare-datatypes () ((Fuel 
(ZFuel) 
(SFuel (prec Fuel)))))
(declare-fun MaxIFuel () Fuel)
(declare-fun MaxFuel () Fuel)
(declare-fun PreKind (Type) Kind)
(declare-fun PreType (Term) Type)
(declare-fun Valid (Type) Bool)
(declare-fun HasKind (Type Kind) Bool)
(declare-fun HasType (Term Type) Bool)
(define-fun  IsTyped ((x Term)) Bool
(exists ((t Type)) (HasType x t)))
(declare-fun HasTypeFuel (Fuel Term Type) Bool)
(declare-fun ApplyEF (Term Fuel) Term)
(declare-fun ApplyEE (Term Term) Term)
(declare-fun ApplyET (Term Type) Term)
(declare-fun ApplyTE (Type Term) Type)
(declare-fun ApplyTT (Type Type) Type)
(declare-fun Rank (Term) Int)
(declare-fun Closure (Term) Term)
(declare-fun ConsTerm (Term Term) Term)
(declare-fun ConsType (Type Term) Term)
(declare-fun ConsFuel (Fuel Term) Term)
(declare-fun Precedes (Term Term) Type)
(assert (forall ((e Term) (t Type))
(!  (= (HasType e t)
(HasTypeFuel MaxIFuel e t))
:pattern ((HasType e t)))))
(assert (forall ((f Fuel) (e Term) (t Type)) 
(! (= (HasTypeFuel (SFuel f) e t)
(HasTypeFuel f e t))
:pattern ((HasTypeFuel (SFuel f) e t)))))
(assert (forall ((t1 Term) (t2 Term))
(! (iff (Valid (Precedes t1 t2)) 
(< (Rank t1) (Rank t2)))
:pattern ((Precedes t1 t2)))))
(define-fun Prims.Precedes ((a Type) (b Type) (t1 Term) (t2 Term)) Type
(Precedes t1 t2))

; <start constructor String_const>
;;;;;;;;;;;;;;;;Constructor
(declare-fun String_const (Int) String)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Int))
 (= 0
(String_constr_id (String_const @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun String_const_proj_0 (String) Int)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Int))
 (! (= (String_const_proj_0 (String_const @u0))
@u0)
  
:pattern ((String_const @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-String_const ((@u0 String)) Bool
 (and (= (String_constr_id @u0)
0)
(= @u0
(String_const (String_const_proj_0 @u0)))))

; </end constructor String_const>

; <start constructor Kind_type>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Kind_type () Kind)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 0
(Kind_constr_id Kind_type)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Kind_type ((@u0 Kind)) Bool
 (and (= (Kind_constr_id @u0)
0)
(= @u0
Kind_type)))

; </end constructor Kind_type>

; <start constructor Kind_arrow>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Kind_arrow (Int) Kind)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Int))
 (= 1
(Kind_constr_id (Kind_arrow @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Kind_arrow_id (Kind) Int)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Int))
 (! (= (Kind_arrow_id (Kind_arrow @u0))
@u0)
  
:pattern ((Kind_arrow @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Kind_arrow ((@u0 Kind)) Bool
 (and (= (Kind_constr_id @u0)
1)
(= @u0
(Kind_arrow (Kind_arrow_id @u0)))))

; </end constructor Kind_arrow>

; <start constructor Typ_fun>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Typ_fun (Int) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Int))
 (= 1
(Type_constr_id (Typ_fun @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Typ_fun_id (Type) Int)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Int))
 (! (= (Typ_fun_id (Typ_fun @u0))
@u0)
  
:pattern ((Typ_fun @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Typ_fun ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
1)
(= @a0
(Typ_fun (Typ_fun_id @a0)))))

; </end constructor Typ_fun>

; <start constructor Typ_app>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Typ_app (Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type))
 (= 2
(Type_constr_id (Typ_app @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Typ_app_fst (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Typ_app_fst (Typ_app @a0
@a1))
@a0)
  
:pattern ((Typ_app @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Typ_app_snd (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Typ_app_snd (Typ_app @a0
@a1))
@a1)
  
:pattern ((Typ_app @a0
@a1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Typ_app ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
2)
(= @a0
(Typ_app (Typ_app_fst @a0)
(Typ_app_snd @a0)))))

; </end constructor Typ_app>

; <start constructor Typ_dep>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Typ_dep (Type Term) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term))
 (= 3
(Type_constr_id (Typ_dep @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Typ_dep_fst (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Typ_dep_fst (Typ_dep @a0
@x1))
@a0)
  
:pattern ((Typ_dep @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Typ_dep_snd (Type) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Typ_dep_snd (Typ_dep @a0
@x1))
@x1)
  
:pattern ((Typ_dep @a0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Typ_dep ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
3)
(= @a0
(Typ_dep (Typ_dep_fst @a0)
(Typ_dep_snd @a0)))))

; </end constructor Typ_dep>

; <start constructor Typ_uvar>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Typ_uvar (Int) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Int))
 (= 4
(Type_constr_id (Typ_uvar @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Typ_uvar_fst (Type) Int)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Int))
 (! (= (Typ_uvar_fst (Typ_uvar @u0))
@u0)
  
:pattern ((Typ_uvar @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Typ_uvar ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
4)
(= @a0
(Typ_uvar (Typ_uvar_fst @a0)))))

; </end constructor Typ_uvar>

; <start constructor Term_unit>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Term_unit () Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 0
(Term_constr_id Term_unit)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Term_unit ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
0)
(= @x0
Term_unit)))

; </end constructor Term_unit>

; <start constructor BoxInt>
;;;;;;;;;;;;;;;;Constructor
(declare-fun BoxInt (Int) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Int))
 (= 1
(Term_constr_id (BoxInt @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun BoxInt_proj_0 (Term) Int)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Int))
 (! (= (BoxInt_proj_0 (BoxInt @u0))
@u0)
  
:pattern ((BoxInt @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-BoxInt ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1)
(= @x0
(BoxInt (BoxInt_proj_0 @x0)))))

; </end constructor BoxInt>

; <start constructor BoxBool>
;;;;;;;;;;;;;;;;Constructor
(declare-fun BoxBool (Bool) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Bool))
 (= 2
(Term_constr_id (BoxBool @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun BoxBool_proj_0 (Term) Bool)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Bool))
 (! (= (BoxBool_proj_0 (BoxBool @u0))
@u0)
  
:pattern ((BoxBool @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-BoxBool ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
2)
(= @x0
(BoxBool (BoxBool_proj_0 @x0)))))

; </end constructor BoxBool>

; <start constructor BoxString>
;;;;;;;;;;;;;;;;Constructor
(declare-fun BoxString (String) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 String))
 (= 3
(Term_constr_id (BoxString @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun BoxString_proj_0 (Term) String)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 String))
 (! (= (BoxString_proj_0 (BoxString @u0))
@u0)
  
:pattern ((BoxString @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-BoxString ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
3)
(= @x0
(BoxString (BoxString_proj_0 @x0)))))

; </end constructor BoxString>

; <start constructor BoxRef>
;;;;;;;;;;;;;;;;Constructor
(declare-fun BoxRef (Ref) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Ref))
 (= 4
(Term_constr_id (BoxRef @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun BoxRef_proj_0 (Term) Ref)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Ref))
 (! (= (BoxRef_proj_0 (BoxRef @u0))
@u0)
  
:pattern ((BoxRef @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-BoxRef ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
4)
(= @x0
(BoxRef (BoxRef_proj_0 @x0)))))

; </end constructor BoxRef>

; <start constructor Exp_uvar>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Exp_uvar (Int) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@u0 Int))
 (= 5
(Term_constr_id (Exp_uvar @u0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Exp_uvar_fst (Term) Int)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@u0 Int))
 (! (= (Exp_uvar_fst (Exp_uvar @u0))
@u0)
  
:pattern ((Exp_uvar @u0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Exp_uvar ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
5)
(= @x0
(Exp_uvar (Exp_uvar_fst @x0)))))

; </end constructor Exp_uvar>

; <start constructor LexCons>
;;;;;;;;;;;;;;;;Constructor
(declare-fun LexCons (Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term) (@x1 Term))
 (= 6
(Term_constr_id (LexCons @x0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun LexCons_0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (LexCons_0 (LexCons @x0
@x1))
@x0)
  
:pattern ((LexCons @x0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun LexCons_1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (LexCons_1 (LexCons @x0
@x1))
@x1)
  
:pattern ((LexCons @x0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-LexCons ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
6)
(= @x0
(LexCons (LexCons_0 @x0)
(LexCons_1 @x0)))))

; </end constructor LexCons>
(define-fun is-Prims.LexCons ((t Term)) Bool 
(is-LexCons t))
(assert (forall ((x1 Term) (x2 Term) (y1 Term) (y2 Term))
(iff (Valid (Precedes (LexCons x1 x2) (LexCons y1 y2)))
(or (Valid (Precedes x1 y1))
(and (= x1 y1)
(Valid (Precedes x2 y2)))))))


; encoding sigelt Prims.Unop

; <Skipped Prims.Unop/>

; encoding sigelt Prims.Binop

; <Skipped Prims.Binop/>

; encoding sigelt Prims.l_not

; <Start encoding Prims.l_not>
(declare-fun Prims.l_not (Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.l_not@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 15
(Type_constr_id Prims.l_not@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.l_not@tok
@a0)
(Prims.l_not @a0))
  
:pattern ((ApplyTT Prims.l_not@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.l_not@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.l_not @a0)
Kind_type))
  
:pattern ((Prims.l_not @a0)))))

; </end encoding Prims.l_not>

; encoding sigelt Prims.l_and

; <Start encoding Prims.l_and>
(declare-fun Prims.l_and (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.l_and@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 17
(Type_constr_id Prims.l_and@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.l_and@tok
@a0)
@a1)
(Prims.l_and @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.l_and@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.l_and@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.l_and @a0
@a1)
Kind_type))
  
:pattern ((Prims.l_and @a0
@a1)))))

; </end encoding Prims.l_and>

; encoding sigelt Prims.l_or

; <Start encoding Prims.l_or>
(declare-fun Prims.l_or (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.l_or@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 19
(Type_constr_id Prims.l_or@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.l_or@tok
@a0)
@a1)
(Prims.l_or @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.l_or@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.l_or@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.l_or @a0
@a1)
Kind_type))
  
:pattern ((Prims.l_or @a0
@a1)))))

; </end encoding Prims.l_or>

; encoding sigelt Prims.l_iff

; <Start encoding Prims.l_iff>
(declare-fun Prims.l_iff (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.l_iff@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 21
(Type_constr_id Prims.l_iff@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.l_iff@tok
@a0)
@a1)
(Prims.l_iff @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.l_iff@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.l_iff@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.l_iff @a0
@a1)
Kind_type))
  
:pattern ((Prims.l_iff @a0
@a1)))))

; </end encoding Prims.l_iff>

; encoding sigelt Prims.l_imp

; <Start encoding Prims.l_imp>
(declare-fun Prims.l_imp (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.l_imp@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 23
(Type_constr_id Prims.l_imp@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.l_imp@tok
@a0)
@a1)
(Prims.l_imp @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.l_imp@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.l_imp@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.l_imp @a0
@a1)
Kind_type))
  
:pattern ((Prims.l_imp @a0
@a1)))))

; </end encoding Prims.l_imp>

; encoding sigelt Prims.Forall

; <Start encoding Prims.Forall>
(declare-fun Prims.Forall (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Forall@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 25
(Type_constr_id Prims.Forall@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.Forall@tok
@a0)
@a1)
(Prims.Forall @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.Forall@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Forall@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@a0)
(HasKind (ApplyTE @a1
@x2)
Kind_type))
  
:pattern ((ApplyTE @a1
@x2)))))
(HasKind (Prims.Forall @a0
@a1)
Kind_type))
  
:pattern ((Prims.Forall @a0
@a1)))))

; </end encoding Prims.Forall>

; encoding sigelt Prims.Exists

; <Start encoding Prims.Exists>
(declare-fun Prims.Exists (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Exists@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 27
(Type_constr_id Prims.Exists@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.Exists@tok
@a0)
@a1)
(Prims.Exists @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.Exists@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Exists@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@a0)
(HasKind (ApplyTE @a1
@x2)
Kind_type))
  
:pattern ((ApplyTE @a1
@x2)))))
(HasKind (Prims.Exists @a0
@a1)
Kind_type))
  
:pattern ((Prims.Exists @a0
@a1)))))

; </end encoding Prims.Exists>

; encoding sigelt Prims.ForallTyp

; <Start encoding Prims.ForallTyp>
(declare-fun Prims.ForallTyp (Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.ForallTyp@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 29
(Type_constr_id Prims.ForallTyp@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.ForallTyp@tok
@a0)
(Prims.ForallTyp @a0))
  
:pattern ((ApplyTT Prims.ForallTyp@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.ForallTyp@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (forall ((@a1 Type))
 (! (implies (HasKind @a1
Kind_type)
(HasKind (ApplyTT @a1
@a1)
Kind_type))
  
:pattern ((ApplyTT @a1
@a1))))
(HasKind (Prims.ForallTyp @a0)
Kind_type))
  
:pattern ((Prims.ForallTyp @a0)))))

; </end encoding Prims.ForallTyp>

; encoding sigelt Prims.ExistsTyp

; <Start encoding Prims.ExistsTyp>
(declare-fun Prims.ExistsTyp (Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.ExistsTyp@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 31
(Type_constr_id Prims.ExistsTyp@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.ExistsTyp@tok
@a0)
(Prims.ExistsTyp @a0))
  
:pattern ((ApplyTT Prims.ExistsTyp@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.ExistsTyp@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (forall ((@a1 Type))
 (! (implies (HasKind @a1
Kind_type)
(HasKind (ApplyTT @a1
@a1)
Kind_type))
  
:pattern ((ApplyTT @a1
@a1))))
(HasKind (Prims.ExistsTyp @a0)
Kind_type))
  
:pattern ((Prims.ExistsTyp @a0)))))

; </end encoding Prims.ExistsTyp>

; encoding sigelt Prims.True

; <Start encoding Prims.True>
(declare-fun Prims.True () Type)
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.True
Kind_type))

; </end encoding Prims.True>

; encoding sigelt Prims.False

; <Start encoding Prims.False>
(declare-fun Prims.False () Type)
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.False
Kind_type))

; </end encoding Prims.False>

; encoding sigelt Prims.EqTyp

; <Start encoding Prims.EqTyp>
(declare-fun Prims.EqTyp (Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.EqTyp@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 35
(Type_constr_id Prims.EqTyp@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.EqTyp@tok
@a0)
@a1)
(Prims.EqTyp @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.EqTyp@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.EqTyp@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.EqTyp @a0
@a1)
Kind_type))
  
:pattern ((Prims.EqTyp @a0
@a1)))))

; </end encoding Prims.EqTyp>

; encoding sigelt Prims.Eq2

; <Start encoding Prims.Eq2>
(declare-fun Prims.Eq2 (Type Type Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Eq2@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 37
(Type_constr_id Prims.Eq2@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTT (ApplyTT Prims.Eq2@tok
@a0)
@a1)
@x2)
@x3)
(Prims.Eq2 @a0
@a1
@x2
@x3))
  
:pattern ((ApplyTE (ApplyTE (ApplyTT (ApplyTT Prims.Eq2@tok
@a0)
@a1)
@x2)
@x3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Eq2@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
@a0)
(HasType @x3
@a1))
(HasKind (Prims.Eq2 @a0
@a1
@x2
@x3)
Kind_type))
  
:pattern ((Prims.Eq2 @a0
@a1
@x2
@x3)))))

; </end encoding Prims.Eq2>

; encoding sigelt Prims.XOR

; <Start encoding Prims.XOR>
(declare-fun Prims.XOR (Type Type) Type)
(declare-fun Prims.XOR@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 38
(Type_constr_id Prims.XOR@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.XOR@tok
@a0)
@a1)
(Prims.XOR @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.XOR@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(= (Valid (Prims.XOR @a0
@a1))
(and (or (Valid @a0)
(Valid @a1))
(not (and (Valid @a0)
(Valid @a1))))))
  
:pattern ((Valid (Prims.XOR @a0
@a1))))))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.XOR @a0
@a1)
Kind_type))
  
:pattern ((Prims.XOR @a0
@a1)))))

; </end encoding Prims.XOR>

; encoding sigelt Prims.ITE

; <Start encoding Prims.ITE>
(declare-fun Prims.ITE (Type Type Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.ITE@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 40
(Type_constr_id Prims.ITE@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.ITE@tok
@a0)
@a1)
@a2)
(Prims.ITE @a0
@a1
@a2))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.ITE@tok
@a0)
@a1)
@a2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.ITE@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type))
(HasKind (Prims.ITE @a0
@a1
@a2)
Kind_type))
  
:pattern ((Prims.ITE @a0
@a1
@a2)))))

; </end encoding Prims.ITE>

; encoding sigelt Prims.Precedes

; <Skipped Prims.Precedes/>

; encoding sigelt Prims.bool

; <Start encoding Prims.bool>

; <start constructor Prims.bool>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.bool () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 41
(Type_constr_id Prims.bool)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.bool ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
41)
(= @a0
Prims.bool)))

; </end constructor Prims.bool>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.bool
Kind_type))
;;;;;;;;;;;;;;;;bool inversion
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Prims.bool)
(is-BoxBool @x1))
  
:pattern ((HasTypeFuel @u0
@x1
Prims.bool)))))
;;;;;;;;;;;;;;;;bool typing
(assert (forall ((@u0 Bool))
 (! (HasType (BoxBool @u0)
Prims.bool)
  
:pattern ((BoxBool @u0)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.bool)
(= Prims.bool
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.bool)))))

; </end encoding Prims.bool>

; encoding sigelt Prims.PurePre

; <Skipped Prims.PurePre/>

; encoding sigelt Prims.PurePost

; <Skipped Prims.PurePost/>

; encoding sigelt Prims.PureWP

; <Skipped Prims.PureWP/>

; encoding sigelt Prims.pure_return

; <Skipped Prims.pure_return/>

; encoding sigelt Prims.pure_bind_wlp

; <Skipped Prims.pure_bind_wlp/>

; encoding sigelt Prims.pure_bind_wp

; <Skipped Prims.pure_bind_wp/>

; encoding sigelt Prims.pure_if_then_else

; <Skipped Prims.pure_if_then_else/>

; encoding sigelt Prims.pure_ite_wlp

; <Skipped Prims.pure_ite_wlp/>

; encoding sigelt Prims.pure_ite_wp

; <Skipped Prims.pure_ite_wp/>

; encoding sigelt Prims.pure_wp_binop

; <Skipped Prims.pure_wp_binop/>

; encoding sigelt Prims.pure_wp_as_type

; <Skipped Prims.pure_wp_as_type/>

; encoding sigelt Prims.pure_close_wp

; <Skipped Prims.pure_close_wp/>

; encoding sigelt Prims.pure_close_wp_t

; <Skipped Prims.pure_close_wp_t/>

; encoding sigelt Prims.pure_assert_p

; <Skipped Prims.pure_assert_p/>

; encoding sigelt Prims.pure_assume_p

; <Skipped Prims.pure_assume_p/>

; encoding sigelt Prims.pure_null_wp

; <Skipped Prims.pure_null_wp/>

; encoding sigelt Prims.pure_trivial

; <Skipped Prims.pure_trivial/>

; encoding sigelt Prims.PURE

; <Skipped Prims.PURE/>

; encoding sigelt Prims.Pure

; <Skipped Prims.Pure/>

; encoding sigelt Prims.Admit

; <Skipped Prims.Admit/>

; encoding sigelt Prims.Tot

; <Skipped Prims.Tot/>

; encoding sigelt Prims.GHOST

; <Skipped Prims.GHOST/>

; encoding sigelt 

; <Skipped />

; encoding sigelt Prims.GTot

; <Skipped Prims.GTot/>

; encoding sigelt Prims.Ghost

; <Skipped Prims.Ghost/>

; encoding sigelt Prims.b2t

; <Start encoding Prims.b2t>
(declare-fun Prims.b2t (Term) Type)
;;;;;;;;;;;;;;;;b2t def
(assert (forall ((@x0 Term))
 (! (= (Valid (Prims.b2t @x0))
(BoxBool_proj_0 @x0))
  
:pattern ((Valid (Prims.b2t @x0))))))

; </end encoding Prims.b2t>

; encoding sigelt Prims.unit

; <Start encoding Prims.unit>

; <start constructor Prims.unit>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.unit () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 45
(Type_constr_id Prims.unit)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.unit ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
45)
(= @a0
Prims.unit)))

; </end constructor Prims.unit>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.unit
Kind_type))
;;;;;;;;;;;;;;;;unit typing
(assert (HasType Term_unit
Prims.unit))
;;;;;;;;;;;;;;;;unit inversion
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Prims.unit)
(= @x1
Term_unit))
  
:pattern ((HasTypeFuel @u0
@x1
Prims.unit)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.unit)
(= Prims.unit
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.unit)))))

; </end encoding Prims.unit>

; encoding sigelt Prims.int

; <Start encoding Prims.int>

; <start constructor Prims.int>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.int () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 49
(Type_constr_id Prims.int)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.int ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
49)
(= @a0
Prims.int)))

; </end constructor Prims.int>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.int
Kind_type))
;;;;;;;;;;;;;;;;int inversion
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Prims.int)
(is-BoxInt @x1))
  
:pattern ((HasTypeFuel @u0
@x1
Prims.int)))))
;;;;;;;;;;;;;;;;int typing
(assert (forall ((@u0 Int))
 (! (HasType (BoxInt @u0)
Prims.int)
  
:pattern ((BoxInt @u0)))))
;;;;;;;;;;;;;;;;well-founded ordering on nat (alt)
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Prims.int)
(HasType @x2
Prims.int)
(> (BoxInt_proj_0 @x1)
0)
(>= (BoxInt_proj_0 @x2)
0)
(< (BoxInt_proj_0 @x2)
(BoxInt_proj_0 @x1)))
(Valid (Precedes @x2
@x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Prims.int) (HasTypeFuel @u0
@x2
Prims.int) (Valid (Precedes @x2
@x1))))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.int)
(= Prims.int
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.int)))))

; </end encoding Prims.int>

; encoding sigelt Prims.op_AmpAmp

; <Start encoding Prims.op_AmpAmp>
(declare-fun Prims.op_AmpAmp (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_AmpAmp>

; encoding sigelt Prims.op_BarBar

; <Start encoding Prims.op_BarBar>
(declare-fun Prims.op_BarBar (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_BarBar>

; encoding sigelt Prims.op_Negation

; <Start encoding Prims.op_Negation>
(declare-fun Prims.op_Negation (Term) Term)
(assert (forall ((@x0 Term))
 (! (= (Prims.op_Negation @x0)
(BoxBool (not (BoxBool_proj_0 @x0))))
  
:pattern ((Prims.op_Negation @x0)))))

; </end encoding Prims.op_Negation>

; encoding sigelt Prims.op_Multiply

; <Start encoding Prims.op_Multiply>
(declare-fun Prims.op_Multiply (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_Multiply>

; encoding sigelt Prims.op_Subtraction

; <Start encoding Prims.op_Subtraction>
(declare-fun Prims.op_Subtraction (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_Subtraction>

; encoding sigelt Prims.op_Addition

; <Start encoding Prims.op_Addition>
(declare-fun Prims.op_Addition (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_Addition>

; encoding sigelt Prims.op_Minus

; <Start encoding Prims.op_Minus>
(declare-fun Prims.op_Minus (Term) Term)
(assert (forall ((@x0 Term))
 (! (= (Prims.op_Minus @x0)
(BoxInt (- (BoxInt_proj_0 @x0))))
  
:pattern ((Prims.op_Minus @x0)))))

; </end encoding Prims.op_Minus>

; encoding sigelt Prims.op_LessThanOrEqual

; <Start encoding Prims.op_LessThanOrEqual>
(declare-fun Prims.op_LessThanOrEqual (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_LessThanOrEqual>

; encoding sigelt Prims.op_GreaterThan

; <Start encoding Prims.op_GreaterThan>
(declare-fun Prims.op_GreaterThan (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_GreaterThan>

; encoding sigelt Prims.op_GreaterThanOrEqual

; <Start encoding Prims.op_GreaterThanOrEqual>
(declare-fun Prims.op_GreaterThanOrEqual (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_GreaterThanOrEqual>

; encoding sigelt Prims.op_LessThan

; <Start encoding Prims.op_LessThan>
(declare-fun Prims.op_LessThan (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_LessThan>

; encoding sigelt Prims.op_Equality

; <Start encoding Prims.op_Equality>
(declare-fun Prims.op_Equality (Type Term Term) Term)
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (! (= (Prims.op_Equality @a0
@x1
@x2)
(BoxBool (= @x1
@x2)))
  
:pattern ((Prims.op_Equality @a0
@x1
@x2)))))

; </end encoding Prims.op_Equality>

; encoding sigelt Prims.op_disEquality

; <Start encoding Prims.op_disEquality>
(declare-fun Prims.op_disEquality (Type Term Term) Term)
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (! (= (Prims.op_disEquality @a0
@x1
@x2)
(BoxBool (not (= @x1
@x2))))
  
:pattern ((Prims.op_disEquality @a0
@x1
@x2)))))

; </end encoding Prims.op_disEquality>

; encoding sigelt Prims.int16

; <Start encoding Prims.int16>
(declare-fun Prims.int16 () Type)
(declare-fun Prims.int16@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.int16@tok
Prims.int16))
(declare-fun Typ_refine_54 () Type)
(assert (HasKind Typ_refine_54
Kind_type))
;;;;;;;;;;;;;;;;i:int{((i > (- 32769)) /\ (32768 > i))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_54)
(and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThan @x1
(Prims.op_Minus (BoxInt 32769)))))
(Valid (Prims.b2t (Prims.op_GreaterThan (BoxInt 32768)
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_54)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.int16
Typ_refine_54))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.int16
Kind_type))

; </end encoding Prims.int16>

; encoding sigelt Prims.int32

; <Start encoding Prims.int32>
(declare-fun Prims.int32 () Type)
(declare-fun Prims.int32@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.int32@tok
Prims.int32))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.int32
Prims.int))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.int32
Kind_type))

; </end encoding Prims.int32>

; encoding sigelt Prims.int64

; <Start encoding Prims.int64>

; <start constructor Prims.int64>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.int64 () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 56
(Type_constr_id Prims.int64)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.int64 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
56)
(= @a0
Prims.int64)))

; </end constructor Prims.int64>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.int64
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.int64)
(= Prims.int64
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.int64)))))

; </end encoding Prims.int64>

; encoding sigelt Prims.uint8

; <Start encoding Prims.uint8>
(declare-fun Prims.uint8 () Type)
;;;;;;;;;;;;;;;;mapping to int; for now
(assert (= Prims.uint8
Prims.int))

; </end encoding Prims.uint8>

; encoding sigelt Prims.uint16

; <Start encoding Prims.uint16>

; <start constructor Prims.uint16>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.uint16 () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 59
(Type_constr_id Prims.uint16)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.uint16 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
59)
(= @a0
Prims.uint16)))

; </end constructor Prims.uint16>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.uint16
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.uint16)
(= Prims.uint16
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.uint16)))))

; </end encoding Prims.uint16>

; encoding sigelt Prims.uint32

; <Start encoding Prims.uint32>

; <start constructor Prims.uint32>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.uint32 () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 62
(Type_constr_id Prims.uint32)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.uint32 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
62)
(= @a0
Prims.uint32)))

; </end constructor Prims.uint32>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.uint32
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.uint32)
(= Prims.uint32
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.uint32)))))

; </end encoding Prims.uint32>

; encoding sigelt Prims.uint64

; <Start encoding Prims.uint64>

; <start constructor Prims.uint64>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.uint64 () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 65
(Type_constr_id Prims.uint64)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.uint64 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
65)
(= @a0
Prims.uint64)))

; </end constructor Prims.uint64>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.uint64
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.uint64)
(= Prims.uint64
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.uint64)))))

; </end encoding Prims.uint64>

; encoding sigelt Prims.char

; <Start encoding Prims.char>
(declare-fun Prims.char () Type)
;;;;;;;;;;;;;;;;mapping to int; for now
(assert (= Prims.char
Prims.int))

; </end encoding Prims.char>

; encoding sigelt Prims.float

; <Start encoding Prims.float>

; <start constructor Prims.float>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.float () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 68
(Type_constr_id Prims.float)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.float ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
68)
(= @a0
Prims.float)))

; </end constructor Prims.float>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.float
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.float)
(= Prims.float
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.float)))))

; </end encoding Prims.float>

; encoding sigelt Prims.string

; <Start encoding Prims.string>

; <start constructor Prims.string>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.string () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 71
(Type_constr_id Prims.string)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.string ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
71)
(= @a0
Prims.string)))

; </end constructor Prims.string>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.string
Kind_type))
;;;;;;;;;;;;;;;;string inversion
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Prims.string)
(is-BoxString @x1))
  
:pattern ((HasTypeFuel @u0
@x1
Prims.string)))))
;;;;;;;;;;;;;;;;string typing
(assert (forall ((@u0 String))
 (! (HasType (BoxString @u0)
Prims.string)
  
:pattern ((BoxString @u0)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.string)
(= Prims.string
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.string)))))

; </end encoding Prims.string>

; encoding sigelt Prims.array

; <Start encoding Prims.array>

; <start constructor Prims.array>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.array (Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 75
(Type_constr_id (Prims.array @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.array@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.array@a0 (Prims.array @a0))
@a0)
  
:pattern ((Prims.array @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.array ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
75)
(= @a0
(Prims.array (Prims.array@a0 @a0)))))

; </end constructor Prims.array>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.array@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 76
(Type_constr_id Prims.array@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.array@tok
@a0)
(Prims.array @a0))
  
:pattern ((ApplyTT Prims.array@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.array@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.array @a0)
Kind_type))
  
:pattern ((Prims.array @a0)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.array @a2))
(= (Prims.array @a2)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.array @a2))))))

; </end encoding Prims.array>

; encoding sigelt Prims.ref

; <Start encoding Prims.ref>

; <start constructor Prims.ref>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.ref (Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 79
(Type_constr_id (Prims.ref @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.ref@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.ref@a0 (Prims.ref @a0))
@a0)
  
:pattern ((Prims.ref @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.ref ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
79)
(= @a0
(Prims.ref (Prims.ref@a0 @a0)))))

; </end constructor Prims.ref>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.ref@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 80
(Type_constr_id Prims.ref@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.ref@tok
@a0)
(Prims.ref @a0))
  
:pattern ((ApplyTT Prims.ref@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.ref@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.ref @a0)
Kind_type))
  
:pattern ((Prims.ref @a0)))))
;;;;;;;;;;;;;;;;ref inversion
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (implies (HasType @x1
(Prims.ref @a2))
(is-BoxRef @x1))
  
:pattern ((HasTypeFuel @u0
@x1
(Prims.ref @a2))))))
;;;;;;;;;;;;;;;;ref typing is injective
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type))
 (! (implies (and (HasType @x1
(Prims.ref @a2))
(HasType @x1
(Prims.ref @a3)))
(= @a2
@a3))
  
:pattern ((HasTypeFuel @u0
@x1
(Prims.ref @a2)) (HasTypeFuel @u0
@x1
(Prims.ref @a3))))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.ref @a2))
(= (Prims.ref @a2)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.ref @a2))))))

; </end encoding Prims.ref>

; encoding sigelt Prims.LBL

; <Start encoding Prims.LBL>
(declare-fun Prims.LBL (Term Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.LBL@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 86
(Type_constr_id Prims.LBL@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@x0 Term) (@a1 Type))
 (! (= (ApplyTT (ApplyTE Prims.LBL@tok
@x0)
@a1)
(Prims.LBL @x0
@a1))
  
:pattern ((ApplyTT (ApplyTE Prims.LBL@tok
@x0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.LBL@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@x0 Term) (@a1 Type))
 (! (implies (and (HasType @x0
Prims.string)
(HasKind @a1
Kind_type))
(HasKind (Prims.LBL @x0
@a1)
Kind_type))
  
:pattern ((Prims.LBL @x0
@a1)))))

; </end encoding Prims.LBL>

; encoding sigelt Prims.exn

; <Start encoding Prims.exn>

; <start constructor Prims.exn>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.exn () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 87
(Type_constr_id Prims.exn)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.exn ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
87)
(= @a0
Prims.exn)))

; </end constructor Prims.exn>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.exn
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.exn)
(= Prims.exn
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.exn)))))

; </end encoding Prims.exn>

; encoding sigelt Prims.HashMultiMap

; <Start encoding Prims.HashMultiMap>

; <start constructor Prims.HashMultiMap>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.HashMultiMap (Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type))
 (= 90
(Type_constr_id (Prims.HashMultiMap @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.HashMultiMap@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.HashMultiMap@a0 (Prims.HashMultiMap @a0
@a1))
@a0)
  
:pattern ((Prims.HashMultiMap @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.HashMultiMap@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.HashMultiMap@a1 (Prims.HashMultiMap @a0
@a1))
@a1)
  
:pattern ((Prims.HashMultiMap @a0
@a1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.HashMultiMap ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
90)
(= @a0
(Prims.HashMultiMap (Prims.HashMultiMap@a0 @a0)
(Prims.HashMultiMap@a1 @a0)))))

; </end constructor Prims.HashMultiMap>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.HashMultiMap@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 91
(Type_constr_id Prims.HashMultiMap@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.HashMultiMap@tok
@a0)
@a1)
(Prims.HashMultiMap @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.HashMultiMap@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.HashMultiMap@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.HashMultiMap @a0
@a1)
Kind_type))
  
:pattern ((Prims.HashMultiMap @a0
@a1)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.HashMultiMap @a2
@a3))
(= (Prims.HashMultiMap @a2
@a3)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.HashMultiMap @a2
@a3))))))

; </end encoding Prims.HashMultiMap>

; encoding sigelt Prims.byte

; <Start encoding Prims.byte>
(declare-fun Prims.byte () Type)
(declare-fun Prims.byte@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.byte@tok
Prims.byte))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.byte
Prims.uint8))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.byte
Kind_type))

; </end encoding Prims.byte>

; encoding sigelt Prims.double

; <Start encoding Prims.double>
(declare-fun Prims.double () Type)
(declare-fun Prims.double@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.double@tok
Prims.double))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.double
Prims.float))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.double
Kind_type))

; </end encoding Prims.double>

; encoding sigelt Prims.list, Prims.Nil, Prims.Cons

; <Start encoding >

; <Start encoding Prims.list>

; <start constructor Prims.list>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.list (Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 112
(Type_constr_id (Prims.list @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.list@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.list@a0 (Prims.list @a0))
@a0)
  
:pattern ((Prims.list @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.list ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
112)
(= @a0
(Prims.list (Prims.list@a0 @a0)))))

; </end constructor Prims.list>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.list@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 113
(Type_constr_id Prims.list@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.list@tok
@a0)
(Prims.list @a0))
  
:pattern ((ApplyTT Prims.list@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.list@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.list @a0)
Kind_type))
  
:pattern ((Prims.list @a0)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.list @a2))
(= (Prims.list @a2)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.list @a2))))))

; </end encoding Prims.list>

; <Start encoding Prims.Nil>

; <start constructor Prims.Nil>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Nil (Type) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 119
(Term_constr_id (Prims.Nil @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Nil_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.Nil_a (Prims.Nil @a0))
@a0)
  
:pattern ((Prims.Nil @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Nil ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
119)
(= @x0
(Prims.Nil (Prims.Nil_a @x0)))))

; </end constructor Prims.Nil>
;;;;;;;;;;;;;;;;( -> Tot (list a))
(declare-fun Typ_fun_121 () Type)
;;;;;;;;;;;;;;;;Typ_fun_121 kinding
(assert (HasKind Typ_fun_121
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_121)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_121)))))
;;;;;;;;;;;;;;;;Typ_fun_121 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_121)
(forall ((@a2 Type))
 (! (implies (HasKind @a2
Kind_type)
(HasType (ApplyET @x1
@a2)
(Prims.list @a2)))
  
:pattern ((ApplyET @x1
@a2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_121)))))
;;;;;;;;;;;;;;;;data constructor proxy: Nil
(declare-fun Prims.Nil@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 124
(Term_constr_id Prims.Nil@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.Nil@tok
Typ_fun_121))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type))
 (! (= (ApplyET Prims.Nil@tok
@a0)
(Prims.Nil @a0))
  
:pattern ((ApplyET Prims.Nil@tok
@a0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type))
 (! (implies (HasKind @a1
Kind_type)
(HasTypeFuel @u0
(Prims.Nil @a1)
(Prims.list @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.Nil @a1)
(Prims.list @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Nil @a1)
(Prims.list @a2))
(and (= @a1
@a2)
(HasKind @a1
Kind_type)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Nil @a1)
(Prims.list @a2))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert true)

; </end encoding Prims.Nil>

; <Start encoding Prims.Cons>

; <start constructor Prims.Cons>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Cons (Type Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (= 126
(Term_constr_id (Prims.Cons @a0
@x1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Cons_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (! (= (Prims.Cons_a (Prims.Cons @a0
@x1
@x2))
@a0)
  
:pattern ((Prims.Cons @a0
@x1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Cons_hd (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (! (= (Prims.Cons_hd (Prims.Cons @a0
@x1
@x2))
@x1)
  
:pattern ((Prims.Cons @a0
@x1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Cons_tl (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (! (= (Prims.Cons_tl (Prims.Cons @a0
@x1
@x2))
@x2)
  
:pattern ((Prims.Cons @a0
@x1
@x2)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Cons ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
126)
(= @x0
(Prims.Cons (Prims.Cons_a @x0)
(Prims.Cons_hd @x0)
(Prims.Cons_tl @x0)))))

; </end constructor Prims.Cons>
;;;;;;;;;;;;;;;;(hd:a -> tl:(list a) -> Tot (list a))
(declare-fun Typ_fun_128 () Type)
;;;;;;;;;;;;;;;;Typ_fun_128 kinding
(assert (HasKind Typ_fun_128
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_128)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_128)))))
;;;;;;;;;;;;;;;;Typ_fun_128 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_128)
(forall ((@a2 Type) (@x3 Term) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
@a2)
(HasType @x4
(Prims.list @a2)))
(HasType (ApplyEE (ApplyEE (ApplyET @x1
@a2)
@x3)
@x4)
(Prims.list @a2)))
  
:pattern ((ApplyEE (ApplyEE (ApplyET @x1
@a2)
@x3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_128)))))
;;;;;;;;;;;;;;;;data constructor proxy: Cons
(declare-fun Prims.Cons@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 131
(Term_constr_id Prims.Cons@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.Cons@tok
Typ_fun_128))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@x1 Term) (@x2 Term))
 (! (= (ApplyEE (ApplyEE (ApplyET Prims.Cons@tok
@a0)
@x1)
@x2)
(Prims.Cons @a0
@x1
@x2))
  
:pattern ((ApplyEE (ApplyEE (ApplyET Prims.Cons@tok
@a0)
@x1)
@x2)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasTypeFuel (SFuel @u0)
@x2
@a1)
(HasTypeFuel (SFuel @u0)
@x3
(Prims.list @a1)))
(HasTypeFuel @u0
(Prims.Cons @a1
@x2
@x3)
(Prims.list @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.Cons @a1
@x2
@x3)
(Prims.list @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@x3 Term) (@a4 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Cons @a1
@x2
@x3)
(Prims.list @a4))
(and (= @a1
@a4)
(HasKind @a1
Kind_type)
(HasTypeFuel @u0
@x2
@a1)
(HasTypeFuel @u0
@x3
(Prims.list @a1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Cons @a1
@x2
@x3)
(Prims.list @a4))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@x3 Term) (@a4 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Cons @a1
@x2
@x3)
(Prims.list @a4))
(and (Valid (Precedes @x2
(Prims.Cons @a1
@x2
@x3)))
(Valid (Precedes @x3
(Prims.Cons @a1
@x2
@x3)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Cons @a1
@x2
@x3)
(Prims.list @a4))))))

; </end encoding Prims.Cons>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.list @a2))
(or (and (is-Prims.Nil @x1)
(= @a2
(Prims.Nil_a @x1)))
(and (is-Prims.Cons @x1)
(= @a2
(Prims.Cons_a @x1)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.list @a2))))))

; </end encoding >

; encoding sigelt Prims.is_Nil

; <Start encoding Prims.is_Nil>
(declare-fun Prims.is_Nil (Type Term) Term)
;;;;;;;;;;;;;;;;((list a) -> Tot bool)
(declare-fun Typ_fun_133 () Type)
;;;;;;;;;;;;;;;;Typ_fun_133 kinding
(assert (HasKind Typ_fun_133
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_133)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_133)))))
;;;;;;;;;;;;;;;;Typ_fun_133 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_133)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Prims.list @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_133)))))
(declare-fun Prims.is_Nil@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 136
(Term_constr_id Prims.is_Nil@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_Nil@tok
@a0)
@x1)
(Prims.is_Nil @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_Nil@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_Nil@tok
Typ_fun_133))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.list @a0)))
(HasType (Prims.is_Nil @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_Nil @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_Nil @a0
@x1)
(BoxBool (is-Prims.Nil @x1)))
  
:pattern ((Prims.is_Nil @a0
@x1)))))

; </end encoding Prims.is_Nil>

; encoding sigelt Prims.is_Cons

; <Start encoding Prims.is_Cons>
(declare-fun Prims.is_Cons (Type Term) Term)
(declare-fun Prims.is_Cons@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 138
(Term_constr_id Prims.is_Cons@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_Cons@tok
@a0)
@x1)
(Prims.is_Cons @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_Cons@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_Cons@tok
Typ_fun_133))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.list @a0)))
(HasType (Prims.is_Cons @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_Cons @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_Cons @a0
@x1)
(BoxBool (is-Prims.Cons @x1)))
  
:pattern ((Prims.is_Cons @a0
@x1)))))

; </end encoding Prims.is_Cons>

; encoding sigelt Prims.Nil.a

; <Start encoding Prims.Nil.a>
(declare-fun Prims.Nil.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Nil.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 142
(Type_constr_id Prims.Nil.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.Nil.a@tok
@a0)
@x1)
(Prims.Nil.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.Nil.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_139 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_139 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_139 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_115:(list a){(is_Nil _0_115)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_139 @a2))
(and (HasType @x1
(Prims.list @a2))
(Valid (Prims.b2t (Prims.is_Nil @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_139 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Nil.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_139 @a0)))
(HasKind (Prims.Nil.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.Nil.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Nil.a @a0
@x1)
(Prims.Nil_a @x1))
  
:pattern ((Prims.Nil.a @a0
@x1)))))

; </end encoding Prims.Nil.a>

; encoding sigelt Prims.Cons.a

; <Start encoding Prims.Cons.a>
(declare-fun Prims.Cons.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Cons.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 146
(Type_constr_id Prims.Cons.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.Cons.a@tok
@a0)
@x1)
(Prims.Cons.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.Cons.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_143 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_143 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_143 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_117:(list a){(is_Cons _0_117)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_143 @a2))
(and (HasType @x1
(Prims.list @a2))
(Valid (Prims.b2t (Prims.is_Cons @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_143 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Cons.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_143 @a0)))
(HasKind (Prims.Cons.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.Cons.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Cons.a @a0
@x1)
(Prims.Cons_a @x1))
  
:pattern ((Prims.Cons.a @a0
@x1)))))

; </end encoding Prims.Cons.a>

; encoding sigelt Prims.Cons.hd

; <Start encoding Prims.Cons.hd>
(declare-fun Prims.Cons.hd (Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_117:(list a){(is_Cons _0_117)} -> Tot a)
(declare-fun Typ_fun_148 () Type)
;;;;;;;;;;;;;;;;Typ_fun_148 kinding
(assert (HasKind Typ_fun_148
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_148)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_148)))))
;;;;;;;;;;;;;;;;Typ_fun_148 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_148)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Typ_refine_143 @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
@a2))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_148)))))
(declare-fun Prims.Cons.hd@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 151
(Term_constr_id Prims.Cons.hd@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.Cons.hd@tok
@a0)
@x1)
(Prims.Cons.hd @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.Cons.hd@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.Cons.hd@tok
Typ_fun_148))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_143 @a0)))
(HasType (Prims.Cons.hd @a0
@x1)
@a0))
  
:pattern ((Prims.Cons.hd @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Cons.hd @a0
@x1)
(Prims.Cons_hd @x1))
  
:pattern ((Prims.Cons.hd @a0
@x1)))))

; </end encoding Prims.Cons.hd>

; encoding sigelt Prims.Cons.tl

; <Start encoding Prims.Cons.tl>
(declare-fun Prims.Cons.tl (Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_117:(list a){(is_Cons _0_117)} -> Tot (list a))
(declare-fun Typ_fun_153 () Type)
;;;;;;;;;;;;;;;;Typ_fun_153 kinding
(assert (HasKind Typ_fun_153
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_153)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_153)))))
;;;;;;;;;;;;;;;;Typ_fun_153 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_153)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Typ_refine_143 @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
(Prims.list @a2)))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_153)))))
(declare-fun Prims.Cons.tl@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 156
(Term_constr_id Prims.Cons.tl@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.Cons.tl@tok
@a0)
@x1)
(Prims.Cons.tl @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.Cons.tl@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.Cons.tl@tok
Typ_fun_153))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_143 @a0)))
(HasType (Prims.Cons.tl @a0
@x1)
(Prims.list @a0)))
  
:pattern ((Prims.Cons.tl @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Cons.tl @a0
@x1)
(Prims.Cons_tl @x1))
  
:pattern ((Prims.Cons.tl @a0
@x1)))))

; </end encoding Prims.Cons.tl>

; encoding sigelt Prims.pattern, Prims.SMTPat, Prims.SMTPatT

; <Start encoding >

; <Start encoding Prims.pattern>

; <start constructor Prims.pattern>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.pattern () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 174
(Type_constr_id Prims.pattern)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.pattern ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
174)
(= @a0
Prims.pattern)))

; </end constructor Prims.pattern>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.pattern
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.pattern)
(= Prims.pattern
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.pattern)))))

; </end encoding Prims.pattern>

; <Start encoding Prims.SMTPat>

; <start constructor Prims.SMTPat>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.SMTPat (Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term))
 (= 180
(Term_constr_id (Prims.SMTPat @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.SMTPat_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.SMTPat_a (Prims.SMTPat @a0
@x1))
@a0)
  
:pattern ((Prims.SMTPat @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.SMTPat__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.SMTPat__1 (Prims.SMTPat @a0
@x1))
@x1)
  
:pattern ((Prims.SMTPat @a0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.SMTPat ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
180)
(= @x0
(Prims.SMTPat (Prims.SMTPat_a @x0)
(Prims.SMTPat__1 @x0)))))

; </end constructor Prims.SMTPat>
;;;;;;;;;;;;;;;;(_1:a -> Tot pattern)
(declare-fun Typ_fun_182 () Type)
;;;;;;;;;;;;;;;;Typ_fun_182 kinding
(assert (HasKind Typ_fun_182
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_182)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_182)))))
;;;;;;;;;;;;;;;;Typ_fun_182 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_182)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
@a2))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.pattern))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_182)))))
;;;;;;;;;;;;;;;;data constructor proxy: SMTPat
(declare-fun Prims.SMTPat@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 185
(Term_constr_id Prims.SMTPat@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.SMTPat@tok
Typ_fun_182))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.SMTPat@tok
@a0)
@x1)
(Prims.SMTPat @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.SMTPat@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasTypeFuel (SFuel @u0)
@x2
@a1))
(HasTypeFuel @u0
(Prims.SMTPat @a1
@x2)
Prims.pattern))
  
:pattern ((HasTypeFuel @u0
(Prims.SMTPat @a1
@x2)
Prims.pattern)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.SMTPat @a1
@x2)
Prims.pattern)
(and (HasKind @a1
Kind_type)
(HasTypeFuel @u0
@x2
@a1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.SMTPat @a1
@x2)
Prims.pattern)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.SMTPat @a1
@x2)
Prims.pattern)
(Valid (Precedes @x2
(Prims.SMTPat @a1
@x2))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.SMTPat @a1
@x2)
Prims.pattern)))))

; </end encoding Prims.SMTPat>

; <Start encoding Prims.SMTPatT>

; <start constructor Prims.SMTPatT>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.SMTPatT (Type) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 187
(Term_constr_id (Prims.SMTPatT @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.SMTPatT_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.SMTPatT_a (Prims.SMTPatT @a0))
@a0)
  
:pattern ((Prims.SMTPatT @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.SMTPatT ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
187)
(= @x0
(Prims.SMTPatT (Prims.SMTPatT_a @x0)))))

; </end constructor Prims.SMTPatT>
;;;;;;;;;;;;;;;;(a:Type -> Tot pattern)
(declare-fun Typ_fun_189 () Type)
;;;;;;;;;;;;;;;;Typ_fun_189 kinding
(assert (HasKind Typ_fun_189
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_189)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_189)))))
;;;;;;;;;;;;;;;;Typ_fun_189 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_189)
(forall ((@a2 Type))
 (! (implies (HasKind @a2
Kind_type)
(HasType (ApplyET @x1
@a2)
Prims.pattern))
  
:pattern ((ApplyET @x1
@a2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_189)))))
;;;;;;;;;;;;;;;;data constructor proxy: SMTPatT
(declare-fun Prims.SMTPatT@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 192
(Term_constr_id Prims.SMTPatT@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.SMTPatT@tok
Typ_fun_189))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type))
 (! (= (ApplyET Prims.SMTPatT@tok
@a0)
(Prims.SMTPatT @a0))
  
:pattern ((ApplyET Prims.SMTPatT@tok
@a0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type))
 (! (implies (HasKind @a1
Kind_type)
(HasTypeFuel @u0
(Prims.SMTPatT @a1)
Prims.pattern))
  
:pattern ((HasTypeFuel @u0
(Prims.SMTPatT @a1)
Prims.pattern)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.SMTPatT @a1)
Prims.pattern)
(HasKind @a1
Kind_type))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.SMTPatT @a1)
Prims.pattern)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert true)

; </end encoding Prims.SMTPatT>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Prims.pattern)
(or (is-Prims.SMTPat @x1)
(is-Prims.SMTPatT @x1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
Prims.pattern)))))

; </end encoding >

; encoding sigelt Prims.is_SMTPat

; <Start encoding Prims.is_SMTPat>
(declare-fun Prims.is_SMTPat (Term) Term)
;;;;;;;;;;;;;;;;(pattern -> Tot bool)
(declare-fun Typ_fun_194 () Type)
;;;;;;;;;;;;;;;;Typ_fun_194 kinding
(assert (HasKind Typ_fun_194
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_194)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_194)))))
;;;;;;;;;;;;;;;;Typ_fun_194 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_194)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Prims.pattern)
(HasType (ApplyEE @x1
@x2)
Prims.bool))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_194)))))
(declare-fun Prims.is_SMTPat@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 197
(Term_constr_id Prims.is_SMTPat@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Prims.is_SMTPat@tok
@x0)
(Prims.is_SMTPat @x0))
  
:pattern ((ApplyEE Prims.is_SMTPat@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_SMTPat@tok
Typ_fun_194))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.pattern)
(HasType (Prims.is_SMTPat @x0)
Prims.bool))
  
:pattern ((Prims.is_SMTPat @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Prims.is_SMTPat @x0)
(BoxBool (is-Prims.SMTPat @x0)))
  
:pattern ((Prims.is_SMTPat @x0)))))

; </end encoding Prims.is_SMTPat>

; encoding sigelt Prims.is_SMTPatT

; <Start encoding Prims.is_SMTPatT>
(declare-fun Prims.is_SMTPatT (Term) Term)
(declare-fun Prims.is_SMTPatT@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 199
(Term_constr_id Prims.is_SMTPatT@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Prims.is_SMTPatT@tok
@x0)
(Prims.is_SMTPatT @x0))
  
:pattern ((ApplyEE Prims.is_SMTPatT@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_SMTPatT@tok
Typ_fun_194))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.pattern)
(HasType (Prims.is_SMTPatT @x0)
Prims.bool))
  
:pattern ((Prims.is_SMTPatT @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Prims.is_SMTPatT @x0)
(BoxBool (is-Prims.SMTPatT @x0)))
  
:pattern ((Prims.is_SMTPatT @x0)))))

; </end encoding Prims.is_SMTPatT>

; encoding sigelt Prims.SMTPat.a

; <Start encoding Prims.SMTPat.a>
(declare-fun Prims.SMTPat.a (Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.SMTPat.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 203
(Type_constr_id Prims.SMTPat.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@x0 Term))
 (! (= (ApplyTE Prims.SMTPat.a@tok
@x0)
(Prims.SMTPat.a @x0))
  
:pattern ((ApplyTE Prims.SMTPat.a@tok
@x0)))))
(declare-fun Typ_refine_200 () Type)
(assert (HasKind Typ_refine_200
Kind_type))
;;;;;;;;;;;;;;;;_0_121:pattern{(is_SMTPat _0_121)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_200)
(and (HasType @x1
Prims.pattern)
(Valid (Prims.b2t (Prims.is_SMTPat @x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_200)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.SMTPat.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_200)
(HasKind (Prims.SMTPat.a @x0)
Kind_type))
  
:pattern ((Prims.SMTPat.a @x0)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@x0 Term))
 (! (= (Prims.SMTPat.a @x0)
(Prims.SMTPat_a @x0))
  
:pattern ((Prims.SMTPat.a @x0)))))

; </end encoding Prims.SMTPat.a>

; encoding sigelt Prims.SMTPat._1

; <Start encoding Prims.SMTPat._1>
(declare-fun Prims.SMTPat._1 (Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_121:pattern{(is_SMTPat _0_121)} -> Tot (SMTPat.a projectee))
(declare-fun Typ_fun_206 () Type)
;;;;;;;;;;;;;;;;Typ_fun_206 kinding
(assert (HasKind Typ_fun_206
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_206)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_206)))))
;;;;;;;;;;;;;;;;Typ_fun_206 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_206)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_200)
(HasType (ApplyEE @x1
@x2)
(Prims.SMTPat.a @x2)))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_206)))))
(declare-fun Prims.SMTPat._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 209
(Term_constr_id Prims.SMTPat._1@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Prims.SMTPat._1@tok
@x0)
(Prims.SMTPat._1 @x0))
  
:pattern ((ApplyEE Prims.SMTPat._1@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.SMTPat._1@tok
Typ_fun_206))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_200)
(HasType (Prims.SMTPat._1 @x0)
(Prims.SMTPat.a @x0)))
  
:pattern ((Prims.SMTPat._1 @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Prims.SMTPat._1 @x0)
(Prims.SMTPat__1 @x0))
  
:pattern ((Prims.SMTPat._1 @x0)))))

; </end encoding Prims.SMTPat._1>

; encoding sigelt Prims.SMTPatT.a

; <Start encoding Prims.SMTPatT.a>
(declare-fun Prims.SMTPatT.a (Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.SMTPatT.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 213
(Type_constr_id Prims.SMTPatT.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@x0 Term))
 (! (= (ApplyTE Prims.SMTPatT.a@tok
@x0)
(Prims.SMTPatT.a @x0))
  
:pattern ((ApplyTE Prims.SMTPatT.a@tok
@x0)))))
(declare-fun Typ_refine_210 () Type)
(assert (HasKind Typ_refine_210
Kind_type))
;;;;;;;;;;;;;;;;_0_123:pattern{(is_SMTPatT _0_123)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_210)
(and (HasType @x1
Prims.pattern)
(Valid (Prims.b2t (Prims.is_SMTPatT @x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_210)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.SMTPatT.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_210)
(HasKind (Prims.SMTPatT.a @x0)
Kind_type))
  
:pattern ((Prims.SMTPatT.a @x0)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@x0 Term))
 (! (= (Prims.SMTPatT.a @x0)
(Prims.SMTPatT_a @x0))
  
:pattern ((Prims.SMTPatT.a @x0)))))

; </end encoding Prims.SMTPatT.a>

; encoding sigelt Prims.decreases

; <Start encoding Prims.decreases>
(declare-fun Prims.decreases (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.decreases@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 215
(Type_constr_id Prims.decreases@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.decreases@tok
@a0)
@x1)
(Prims.decreases @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.decreases@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.decreases@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0))
(HasKind (Prims.decreases @a0
@x1)
Kind_type))
  
:pattern ((Prims.decreases @a0
@x1)))))

; </end encoding Prims.decreases>

; encoding sigelt Prims.Lemma

; <Skipped Prims.Lemma/>

; encoding sigelt Prims.option, Prims.None, Prims.Some

; <Start encoding >

; <Start encoding Prims.option>

; <start constructor Prims.option>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.option (Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 234
(Type_constr_id (Prims.option @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.option@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.option@a0 (Prims.option @a0))
@a0)
  
:pattern ((Prims.option @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.option ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
234)
(= @a0
(Prims.option (Prims.option@a0 @a0)))))

; </end constructor Prims.option>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.option@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 235
(Type_constr_id Prims.option@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.option@tok
@a0)
(Prims.option @a0))
  
:pattern ((ApplyTT Prims.option@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.option@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.option @a0)
Kind_type))
  
:pattern ((Prims.option @a0)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.option @a2))
(= (Prims.option @a2)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.option @a2))))))

; </end encoding Prims.option>

; <Start encoding Prims.None>

; <start constructor Prims.None>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.None (Type) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 241
(Term_constr_id (Prims.None @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.None_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.None_a (Prims.None @a0))
@a0)
  
:pattern ((Prims.None @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.None ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
241)
(= @x0
(Prims.None (Prims.None_a @x0)))))

; </end constructor Prims.None>
;;;;;;;;;;;;;;;;( -> Tot (option a))
(declare-fun Typ_fun_243 () Type)
;;;;;;;;;;;;;;;;Typ_fun_243 kinding
(assert (HasKind Typ_fun_243
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_243)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_243)))))
;;;;;;;;;;;;;;;;Typ_fun_243 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_243)
(forall ((@a2 Type))
 (! (implies (HasKind @a2
Kind_type)
(HasType (ApplyET @x1
@a2)
(Prims.option @a2)))
  
:pattern ((ApplyET @x1
@a2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_243)))))
;;;;;;;;;;;;;;;;data constructor proxy: None
(declare-fun Prims.None@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 246
(Term_constr_id Prims.None@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.None@tok
Typ_fun_243))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type))
 (! (= (ApplyET Prims.None@tok
@a0)
(Prims.None @a0))
  
:pattern ((ApplyET Prims.None@tok
@a0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type))
 (! (implies (HasKind @a1
Kind_type)
(HasTypeFuel @u0
(Prims.None @a1)
(Prims.option @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.None @a1)
(Prims.option @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.None @a1)
(Prims.option @a2))
(and (= @a1
@a2)
(HasKind @a1
Kind_type)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.None @a1)
(Prims.option @a2))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert true)

; </end encoding Prims.None>

; <Start encoding Prims.Some>

; <start constructor Prims.Some>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Some (Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term))
 (= 248
(Term_constr_id (Prims.Some @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Some_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Some_a (Prims.Some @a0
@x1))
@a0)
  
:pattern ((Prims.Some @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Some_v (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Some_v (Prims.Some @a0
@x1))
@x1)
  
:pattern ((Prims.Some @a0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Some ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
248)
(= @x0
(Prims.Some (Prims.Some_a @x0)
(Prims.Some_v @x0)))))

; </end constructor Prims.Some>
;;;;;;;;;;;;;;;;(v:a -> Tot (option a))
(declare-fun Typ_fun_250 () Type)
;;;;;;;;;;;;;;;;Typ_fun_250 kinding
(assert (HasKind Typ_fun_250
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_250)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_250)))))
;;;;;;;;;;;;;;;;Typ_fun_250 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_250)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
@a2))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
(Prims.option @a2)))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_250)))))
;;;;;;;;;;;;;;;;data constructor proxy: Some
(declare-fun Prims.Some@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 253
(Term_constr_id Prims.Some@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.Some@tok
Typ_fun_250))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.Some@tok
@a0)
@x1)
(Prims.Some @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.Some@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasTypeFuel (SFuel @u0)
@x2
@a1))
(HasTypeFuel @u0
(Prims.Some @a1
@x2)
(Prims.option @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.Some @a1
@x2)
(Prims.option @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Some @a1
@x2)
(Prims.option @a3))
(and (= @a1
@a3)
(HasKind @a1
Kind_type)
(HasTypeFuel @u0
@x2
@a1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Some @a1
@x2)
(Prims.option @a3))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Some @a1
@x2)
(Prims.option @a3))
(Valid (Precedes @x2
(Prims.Some @a1
@x2))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Some @a1
@x2)
(Prims.option @a3))))))

; </end encoding Prims.Some>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.option @a2))
(or (and (is-Prims.None @x1)
(= @a2
(Prims.None_a @x1)))
(and (is-Prims.Some @x1)
(= @a2
(Prims.Some_a @x1)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.option @a2))))))

; </end encoding >

; encoding sigelt Prims.is_None

; <Start encoding Prims.is_None>
(declare-fun Prims.is_None (Type Term) Term)
;;;;;;;;;;;;;;;;((option a) -> Tot bool)
(declare-fun Typ_fun_255 () Type)
;;;;;;;;;;;;;;;;Typ_fun_255 kinding
(assert (HasKind Typ_fun_255
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_255)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_255)))))
;;;;;;;;;;;;;;;;Typ_fun_255 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_255)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Prims.option @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_255)))))
(declare-fun Prims.is_None@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 258
(Term_constr_id Prims.is_None@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_None@tok
@a0)
@x1)
(Prims.is_None @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_None@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_None@tok
Typ_fun_255))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.option @a0)))
(HasType (Prims.is_None @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_None @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_None @a0
@x1)
(BoxBool (is-Prims.None @x1)))
  
:pattern ((Prims.is_None @a0
@x1)))))

; </end encoding Prims.is_None>

; encoding sigelt Prims.is_Some

; <Start encoding Prims.is_Some>
(declare-fun Prims.is_Some (Type Term) Term)
(declare-fun Prims.is_Some@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 260
(Term_constr_id Prims.is_Some@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_Some@tok
@a0)
@x1)
(Prims.is_Some @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_Some@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_Some@tok
Typ_fun_255))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.option @a0)))
(HasType (Prims.is_Some @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_Some @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_Some @a0
@x1)
(BoxBool (is-Prims.Some @x1)))
  
:pattern ((Prims.is_Some @a0
@x1)))))

; </end encoding Prims.is_Some>

; encoding sigelt Prims.None.a

; <Start encoding Prims.None.a>
(declare-fun Prims.None.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.None.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 264
(Type_constr_id Prims.None.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.None.a@tok
@a0)
@x1)
(Prims.None.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.None.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_261 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_261 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_261 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_133:(option a){(is_None _0_133)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_261 @a2))
(and (HasType @x1
(Prims.option @a2))
(Valid (Prims.b2t (Prims.is_None @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_261 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.None.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_261 @a0)))
(HasKind (Prims.None.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.None.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.None.a @a0
@x1)
(Prims.None_a @x1))
  
:pattern ((Prims.None.a @a0
@x1)))))

; </end encoding Prims.None.a>

; encoding sigelt Prims.Some.a

; <Start encoding Prims.Some.a>
(declare-fun Prims.Some.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Some.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 268
(Type_constr_id Prims.Some.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.Some.a@tok
@a0)
@x1)
(Prims.Some.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.Some.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_265 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_265 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_265 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_135:(option a){(is_Some _0_135)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_265 @a2))
(and (HasType @x1
(Prims.option @a2))
(Valid (Prims.b2t (Prims.is_Some @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_265 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Some.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_265 @a0)))
(HasKind (Prims.Some.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.Some.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Some.a @a0
@x1)
(Prims.Some_a @x1))
  
:pattern ((Prims.Some.a @a0
@x1)))))

; </end encoding Prims.Some.a>

; encoding sigelt Prims.Some.v

; <Start encoding Prims.Some.v>
(declare-fun Prims.Some.v (Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_135:(option a){(is_Some _0_135)} -> Tot a)
(declare-fun Typ_fun_270 () Type)
;;;;;;;;;;;;;;;;Typ_fun_270 kinding
(assert (HasKind Typ_fun_270
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_270)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_270)))))
;;;;;;;;;;;;;;;;Typ_fun_270 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_270)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Typ_refine_265 @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
@a2))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_270)))))
(declare-fun Prims.Some.v@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 273
(Term_constr_id Prims.Some.v@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.Some.v@tok
@a0)
@x1)
(Prims.Some.v @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.Some.v@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.Some.v@tok
Typ_fun_270))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_265 @a0)))
(HasType (Prims.Some.v @a0
@x1)
@a0))
  
:pattern ((Prims.Some.v @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Some.v @a0
@x1)
(Prims.Some_v @x1))
  
:pattern ((Prims.Some.v @a0
@x1)))))

; </end encoding Prims.Some.v>

; encoding sigelt Prims.either, Prims.Inl, Prims.Inr

; <Start encoding >

; <Start encoding Prims.either>

; <start constructor Prims.either>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.either (Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type))
 (= 292
(Type_constr_id (Prims.either @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.either@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.either@a0 (Prims.either @a0
@a1))
@a0)
  
:pattern ((Prims.either @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.either@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.either@a1 (Prims.either @a0
@a1))
@a1)
  
:pattern ((Prims.either @a0
@a1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.either ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
292)
(= @a0
(Prims.either (Prims.either@a0 @a0)
(Prims.either@a1 @a0)))))

; </end constructor Prims.either>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.either@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 293
(Type_constr_id Prims.either@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.either@tok
@a0)
@a1)
(Prims.either @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.either@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.either@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.either @a0
@a1)
Kind_type))
  
:pattern ((Prims.either @a0
@a1)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.either @a2
@a3))
(= (Prims.either @a2
@a3)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.either @a2
@a3))))))

; </end encoding Prims.either>

; <Start encoding Prims.Inl>

; <start constructor Prims.Inl>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Inl (Type Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (= 299
(Term_constr_id (Prims.Inl @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Inl__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inl__a (Prims.Inl @a0
@a1
@x2))
@a0)
  
:pattern ((Prims.Inl @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Inl__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inl__b (Prims.Inl @a0
@a1
@x2))
@a1)
  
:pattern ((Prims.Inl @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Inl_v (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inl_v (Prims.Inl @a0
@a1
@x2))
@x2)
  
:pattern ((Prims.Inl @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Inl ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
299)
(= @x0
(Prims.Inl (Prims.Inl__a @x0)
(Prims.Inl__b @x0)
(Prims.Inl_v @x0)))))

; </end constructor Prims.Inl>
;;;;;;;;;;;;;;;;(v:'a -> Tot (either 'a 'b))
(declare-fun Typ_fun_301 () Type)
;;;;;;;;;;;;;;;;Typ_fun_301 kinding
(assert (HasKind Typ_fun_301
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_301)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_301)))))
;;;;;;;;;;;;;;;;Typ_fun_301 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_301)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
@a2))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
(Prims.either @a2
@a3)))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_301)))))
;;;;;;;;;;;;;;;;data constructor proxy: Inl
(declare-fun Prims.Inl@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 304
(Term_constr_id Prims.Inl@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.Inl@tok
Typ_fun_301))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.Inl@tok
@a0)
@a1)
@x2)
(Prims.Inl @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.Inl@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasTypeFuel (SFuel @u0)
@x3
@a1))
(HasTypeFuel @u0
(Prims.Inl @a1
@a2
@x3)
(Prims.either @a1
@a2)))
  
:pattern ((HasTypeFuel @u0
(Prims.Inl @a1
@a2
@x3)
(Prims.either @a1
@a2))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Inl @a1
@a2
@x3)
(Prims.either @a4
@a5))
(and (= @a2
@a5)
(= @a1
@a4)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasTypeFuel @u0
@x3
@a1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Inl @a1
@a2
@x3)
(Prims.either @a4
@a5))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Inl @a1
@a2
@x3)
(Prims.either @a4
@a5))
(Valid (Precedes @x3
(Prims.Inl @a1
@a2
@x3))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Inl @a1
@a2
@x3)
(Prims.either @a4
@a5))))))

; </end encoding Prims.Inl>

; <Start encoding Prims.Inr>

; <start constructor Prims.Inr>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Inr (Type Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (= 306
(Term_constr_id (Prims.Inr @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Inr__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inr__a (Prims.Inr @a0
@a1
@x2))
@a0)
  
:pattern ((Prims.Inr @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Inr__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inr__b (Prims.Inr @a0
@a1
@x2))
@a1)
  
:pattern ((Prims.Inr @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Inr_v (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inr_v (Prims.Inr @a0
@a1
@x2))
@x2)
  
:pattern ((Prims.Inr @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Inr ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
306)
(= @x0
(Prims.Inr (Prims.Inr__a @x0)
(Prims.Inr__b @x0)
(Prims.Inr_v @x0)))))

; </end constructor Prims.Inr>
;;;;;;;;;;;;;;;;(v:'b -> Tot (either 'a 'b))
(declare-fun Typ_fun_308 () Type)
;;;;;;;;;;;;;;;;Typ_fun_308 kinding
(assert (HasKind Typ_fun_308
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_308)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_308)))))
;;;;;;;;;;;;;;;;Typ_fun_308 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_308)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
@a3))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
(Prims.either @a2
@a3)))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_308)))))
;;;;;;;;;;;;;;;;data constructor proxy: Inr
(declare-fun Prims.Inr@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 311
(Term_constr_id Prims.Inr@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.Inr@tok
Typ_fun_308))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.Inr@tok
@a0)
@a1)
@x2)
(Prims.Inr @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.Inr@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasTypeFuel (SFuel @u0)
@x3
@a2))
(HasTypeFuel @u0
(Prims.Inr @a1
@a2
@x3)
(Prims.either @a1
@a2)))
  
:pattern ((HasTypeFuel @u0
(Prims.Inr @a1
@a2
@x3)
(Prims.either @a1
@a2))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Inr @a1
@a2
@x3)
(Prims.either @a4
@a5))
(and (= @a2
@a5)
(= @a1
@a4)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasTypeFuel @u0
@x3
@a2)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Inr @a1
@a2
@x3)
(Prims.either @a4
@a5))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Inr @a1
@a2
@x3)
(Prims.either @a4
@a5))
(Valid (Precedes @x3
(Prims.Inr @a1
@a2
@x3))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Inr @a1
@a2
@x3)
(Prims.either @a4
@a5))))))

; </end encoding Prims.Inr>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.either @a2
@a3))
(or (and (is-Prims.Inl @x1)
(= @a2
(Prims.Inl__a @x1))
(= @a3
(Prims.Inl__b @x1)))
(and (is-Prims.Inr @x1)
(= @a2
(Prims.Inr__a @x1))
(= @a3
(Prims.Inr__b @x1)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.either @a2
@a3))))))

; </end encoding >

; encoding sigelt Prims.is_Inl

; <Start encoding Prims.is_Inl>
(declare-fun Prims.is_Inl (Type Type Term) Term)
;;;;;;;;;;;;;;;;((either 'a 'b) -> Tot bool)
(declare-fun Typ_fun_313 () Type)
;;;;;;;;;;;;;;;;Typ_fun_313 kinding
(assert (HasKind Typ_fun_313
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_313)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_313)))))
;;;;;;;;;;;;;;;;Typ_fun_313 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_313)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.either @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_313)))))
(declare-fun Prims.is_Inl@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 316
(Term_constr_id Prims.is_Inl@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.is_Inl@tok
@a0)
@a1)
@x2)
(Prims.is_Inl @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.is_Inl@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_Inl@tok
Typ_fun_313))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.either @a0
@a1)))
(HasType (Prims.is_Inl @a0
@a1
@x2)
Prims.bool))
  
:pattern ((Prims.is_Inl @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.is_Inl @a0
@a1
@x2)
(BoxBool (is-Prims.Inl @x2)))
  
:pattern ((Prims.is_Inl @a0
@a1
@x2)))))

; </end encoding Prims.is_Inl>

; encoding sigelt Prims.is_Inr

; <Start encoding Prims.is_Inr>
(declare-fun Prims.is_Inr (Type Type Term) Term)
(declare-fun Prims.is_Inr@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 318
(Term_constr_id Prims.is_Inr@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.is_Inr@tok
@a0)
@a1)
@x2)
(Prims.is_Inr @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.is_Inr@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_Inr@tok
Typ_fun_313))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.either @a0
@a1)))
(HasType (Prims.is_Inr @a0
@a1
@x2)
Prims.bool))
  
:pattern ((Prims.is_Inr @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.is_Inr @a0
@a1
@x2)
(BoxBool (is-Prims.Inr @x2)))
  
:pattern ((Prims.is_Inr @a0
@a1
@x2)))))

; </end encoding Prims.is_Inr>

; encoding sigelt Prims.Inl.'a

; <Start encoding Prims.Inl.'a>
(declare-fun Prims.Inl._a (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Inl._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 322
(Type_constr_id Prims.Inl._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.Inl._a@tok
@a0)
@a1)
@x2)
(Prims.Inl._a @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.Inl._a@tok
@a0)
@a1)
@x2)))))
(declare-fun Typ_refine_319 (Type Type) Type)
(assert (forall ((@a0 Type) (@a1 Type))
 (! (HasKind (Typ_refine_319 @a0
@a1)
Kind_type)
  
:pattern ((HasKind (Typ_refine_319 @a0
@a1)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_141:(either 'a 'b){(is_Inl _0_141)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type))
 (! (iff (HasType @x1
(Typ_refine_319 @a2
@a3))
(and (HasType @x1
(Prims.either @a3
@a2))
(Valid (Prims.b2t (Prims.is_Inl @a3
@a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_319 @a2
@a3))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Inl._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Typ_refine_319 @a1
@a0)))
(HasKind (Prims.Inl._a @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.Inl._a @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inl._a @a0
@a1
@x2)
(Prims.Inl__a @x2))
  
:pattern ((Prims.Inl._a @a0
@a1
@x2)))))

; </end encoding Prims.Inl.'a>

; encoding sigelt Prims.Inl.'b

; <Start encoding Prims.Inl.'b>
(declare-fun Prims.Inl._b (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Inl._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 324
(Type_constr_id Prims.Inl._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.Inl._b@tok
@a0)
@a1)
@x2)
(Prims.Inl._b @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.Inl._b@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Inl._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Typ_refine_319 @a1
@a0)))
(HasKind (Prims.Inl._b @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.Inl._b @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inl._b @a0
@a1
@x2)
(Prims.Inl__b @x2))
  
:pattern ((Prims.Inl._b @a0
@a1
@x2)))))

; </end encoding Prims.Inl.'b>

; encoding sigelt Prims.Inl.v

; <Start encoding Prims.Inl.v>
(declare-fun Prims.Inl.v (Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_141:(either 'a 'b){(is_Inl _0_141)} -> Tot 'a)
(declare-fun Typ_fun_326 () Type)
;;;;;;;;;;;;;;;;Typ_fun_326 kinding
(assert (HasKind Typ_fun_326
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_326)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_326)))))
;;;;;;;;;;;;;;;;Typ_fun_326 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_326)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Typ_refine_319 @a3
@a2)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_326)))))
(declare-fun Prims.Inl.v@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 329
(Term_constr_id Prims.Inl.v@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.Inl.v@tok
@a0)
@a1)
@x2)
(Prims.Inl.v @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.Inl.v@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.Inl.v@tok
Typ_fun_326))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Typ_refine_319 @a1
@a0)))
(HasType (Prims.Inl.v @a0
@a1
@x2)
@a0))
  
:pattern ((Prims.Inl.v @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inl.v @a0
@a1
@x2)
(Prims.Inl_v @x2))
  
:pattern ((Prims.Inl.v @a0
@a1
@x2)))))

; </end encoding Prims.Inl.v>

; encoding sigelt Prims.Inr.'a

; <Start encoding Prims.Inr.'a>
(declare-fun Prims.Inr._a (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Inr._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 333
(Type_constr_id Prims.Inr._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.Inr._a@tok
@a0)
@a1)
@x2)
(Prims.Inr._a @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.Inr._a@tok
@a0)
@a1)
@x2)))))
(declare-fun Typ_refine_330 (Type Type) Type)
(assert (forall ((@a0 Type) (@a1 Type))
 (! (HasKind (Typ_refine_330 @a0
@a1)
Kind_type)
  
:pattern ((HasKind (Typ_refine_330 @a0
@a1)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_143:(either 'a 'b){(is_Inr _0_143)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type))
 (! (iff (HasType @x1
(Typ_refine_330 @a2
@a3))
(and (HasType @x1
(Prims.either @a3
@a2))
(Valid (Prims.b2t (Prims.is_Inr @a3
@a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_330 @a2
@a3))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Inr._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Typ_refine_330 @a1
@a0)))
(HasKind (Prims.Inr._a @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.Inr._a @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inr._a @a0
@a1
@x2)
(Prims.Inr__a @x2))
  
:pattern ((Prims.Inr._a @a0
@a1
@x2)))))

; </end encoding Prims.Inr.'a>

; encoding sigelt Prims.Inr.'b

; <Start encoding Prims.Inr.'b>
(declare-fun Prims.Inr._b (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Inr._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 335
(Type_constr_id Prims.Inr._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.Inr._b@tok
@a0)
@a1)
@x2)
(Prims.Inr._b @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.Inr._b@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Inr._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Typ_refine_330 @a1
@a0)))
(HasKind (Prims.Inr._b @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.Inr._b @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inr._b @a0
@a1
@x2)
(Prims.Inr__b @x2))
  
:pattern ((Prims.Inr._b @a0
@a1
@x2)))))

; </end encoding Prims.Inr.'b>

; encoding sigelt Prims.Inr.v

; <Start encoding Prims.Inr.v>
(declare-fun Prims.Inr.v (Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_143:(either 'a 'b){(is_Inr _0_143)} -> Tot 'b)
(declare-fun Typ_fun_337 () Type)
;;;;;;;;;;;;;;;;Typ_fun_337 kinding
(assert (HasKind Typ_fun_337
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_337)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_337)))))
;;;;;;;;;;;;;;;;Typ_fun_337 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_337)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Typ_refine_330 @a3
@a2)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_337)))))
(declare-fun Prims.Inr.v@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 340
(Term_constr_id Prims.Inr.v@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.Inr.v@tok
@a0)
@a1)
@x2)
(Prims.Inr.v @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.Inr.v@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.Inr.v@tok
Typ_fun_337))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Typ_refine_330 @a1
@a0)))
(HasType (Prims.Inr.v @a0
@a1
@x2)
@a1))
  
:pattern ((Prims.Inr.v @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.Inr.v @a0
@a1
@x2)
(Prims.Inr_v @x2))
  
:pattern ((Prims.Inr.v @a0
@a1
@x2)))))

; </end encoding Prims.Inr.v>

; encoding sigelt Prims.result, Prims.V, Prims.E, Prims.Err

; <Start encoding >

; <Start encoding Prims.result>

; <start constructor Prims.result>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.result (Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type))
 (= 366
(Type_constr_id (Prims.result @a0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.result@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type))
 (! (= (Prims.result@a0 (Prims.result @a0))
@a0)
  
:pattern ((Prims.result @a0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.result ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
366)
(= @a0
(Prims.result (Prims.result@a0 @a0)))))

; </end constructor Prims.result>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.result@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 367
(Type_constr_id Prims.result@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.result@tok
@a0)
(Prims.result @a0))
  
:pattern ((ApplyTT Prims.result@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.result@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.result @a0)
Kind_type))
  
:pattern ((Prims.result @a0)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.result @a2))
(= (Prims.result @a2)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.result @a2))))))

; </end encoding Prims.result>

; <Start encoding Prims.V>

; <start constructor Prims.V>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.V (Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term))
 (= 373
(Term_constr_id (Prims.V @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.V_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.V_a (Prims.V @a0
@x1))
@a0)
  
:pattern ((Prims.V @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.V_v (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.V_v (Prims.V @a0
@x1))
@x1)
  
:pattern ((Prims.V @a0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.V ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
373)
(= @x0
(Prims.V (Prims.V_a @x0)
(Prims.V_v @x0)))))

; </end constructor Prims.V>
;;;;;;;;;;;;;;;;(v:a -> Tot (result a))
(declare-fun Typ_fun_375 () Type)
;;;;;;;;;;;;;;;;Typ_fun_375 kinding
(assert (HasKind Typ_fun_375
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_375)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_375)))))
;;;;;;;;;;;;;;;;Typ_fun_375 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_375)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
@a2))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
(Prims.result @a2)))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_375)))))
;;;;;;;;;;;;;;;;data constructor proxy: V
(declare-fun Prims.V@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 378
(Term_constr_id Prims.V@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.V@tok
Typ_fun_375))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.V@tok
@a0)
@x1)
(Prims.V @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.V@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasTypeFuel (SFuel @u0)
@x2
@a1))
(HasTypeFuel @u0
(Prims.V @a1
@x2)
(Prims.result @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.V @a1
@x2)
(Prims.result @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.V @a1
@x2)
(Prims.result @a3))
(and (= @a1
@a3)
(HasKind @a1
Kind_type)
(HasTypeFuel @u0
@x2
@a1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.V @a1
@x2)
(Prims.result @a3))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.V @a1
@x2)
(Prims.result @a3))
(Valid (Precedes @x2
(Prims.V @a1
@x2))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.V @a1
@x2)
(Prims.result @a3))))))

; </end encoding Prims.V>

; <Start encoding Prims.E>

; <start constructor Prims.E>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.E (Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term))
 (= 380
(Term_constr_id (Prims.E @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.E_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.E_a (Prims.E @a0
@x1))
@a0)
  
:pattern ((Prims.E @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.E_e (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.E_e (Prims.E @a0
@x1))
@x1)
  
:pattern ((Prims.E @a0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.E ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
380)
(= @x0
(Prims.E (Prims.E_a @x0)
(Prims.E_e @x0)))))

; </end constructor Prims.E>
;;;;;;;;;;;;;;;;(e:exn -> Tot (result a))
(declare-fun Typ_fun_382 () Type)
;;;;;;;;;;;;;;;;Typ_fun_382 kinding
(assert (HasKind Typ_fun_382
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_382)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_382)))))
;;;;;;;;;;;;;;;;Typ_fun_382 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_382)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
Prims.exn))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
(Prims.result @a2)))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_382)))))
;;;;;;;;;;;;;;;;data constructor proxy: E
(declare-fun Prims.E@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 385
(Term_constr_id Prims.E@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.E@tok
Typ_fun_382))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.E@tok
@a0)
@x1)
(Prims.E @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.E@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasTypeFuel (SFuel @u0)
@x2
Prims.exn))
(HasTypeFuel @u0
(Prims.E @a1
@x2)
(Prims.result @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.E @a1
@x2)
(Prims.result @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.E @a1
@x2)
(Prims.result @a3))
(and (= @a1
@a3)
(HasKind @a1
Kind_type)
(HasTypeFuel @u0
@x2
Prims.exn)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.E @a1
@x2)
(Prims.result @a3))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.E @a1
@x2)
(Prims.result @a3))
(Valid (Precedes @x2
(Prims.E @a1
@x2))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.E @a1
@x2)
(Prims.result @a3))))))

; </end encoding Prims.E>

; <Start encoding Prims.Err>

; <start constructor Prims.Err>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Err (Type Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@x1 Term))
 (= 387
(Term_constr_id (Prims.Err @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Err_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Err_a (Prims.Err @a0
@x1))
@a0)
  
:pattern ((Prims.Err @a0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Err_msg (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Err_msg (Prims.Err @a0
@x1))
@x1)
  
:pattern ((Prims.Err @a0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Err ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
387)
(= @x0
(Prims.Err (Prims.Err_a @x0)
(Prims.Err_msg @x0)))))

; </end constructor Prims.Err>
;;;;;;;;;;;;;;;;(msg:string -> Tot (result a))
(declare-fun Typ_fun_389 () Type)
;;;;;;;;;;;;;;;;Typ_fun_389 kinding
(assert (HasKind Typ_fun_389
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_389)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_389)))))
;;;;;;;;;;;;;;;;Typ_fun_389 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_389)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
Prims.string))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
(Prims.result @a2)))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_389)))))
;;;;;;;;;;;;;;;;data constructor proxy: Err
(declare-fun Prims.Err@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 392
(Term_constr_id Prims.Err@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.Err@tok
Typ_fun_389))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.Err@tok
@a0)
@x1)
(Prims.Err @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.Err@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasTypeFuel (SFuel @u0)
@x2
Prims.string))
(HasTypeFuel @u0
(Prims.Err @a1
@x2)
(Prims.result @a1)))
  
:pattern ((HasTypeFuel @u0
(Prims.Err @a1
@x2)
(Prims.result @a1))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Err @a1
@x2)
(Prims.result @a3))
(and (= @a1
@a3)
(HasKind @a1
Kind_type)
(HasTypeFuel @u0
@x2
Prims.string)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Err @a1
@x2)
(Prims.result @a3))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@x2 Term) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.Err @a1
@x2)
(Prims.result @a3))
(Valid (Precedes @x2
(Prims.Err @a1
@x2))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.Err @a1
@x2)
(Prims.result @a3))))))

; </end encoding Prims.Err>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.result @a2))
(or (and (is-Prims.V @x1)
(= @a2
(Prims.V_a @x1)))
(and (is-Prims.E @x1)
(= @a2
(Prims.E_a @x1)))
(and (is-Prims.Err @x1)
(= @a2
(Prims.Err_a @x1)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.result @a2))))))

; </end encoding >

; encoding sigelt Prims.is_V

; <Start encoding Prims.is_V>
(declare-fun Prims.is_V (Type Term) Term)
;;;;;;;;;;;;;;;;((result a) -> Tot bool)
(declare-fun Typ_fun_394 () Type)
;;;;;;;;;;;;;;;;Typ_fun_394 kinding
(assert (HasKind Typ_fun_394
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_394)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_394)))))
;;;;;;;;;;;;;;;;Typ_fun_394 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_394)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Prims.result @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_394)))))
(declare-fun Prims.is_V@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 397
(Term_constr_id Prims.is_V@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_V@tok
@a0)
@x1)
(Prims.is_V @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_V@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_V@tok
Typ_fun_394))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.result @a0)))
(HasType (Prims.is_V @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_V @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_V @a0
@x1)
(BoxBool (is-Prims.V @x1)))
  
:pattern ((Prims.is_V @a0
@x1)))))

; </end encoding Prims.is_V>

; encoding sigelt Prims.is_E

; <Start encoding Prims.is_E>
(declare-fun Prims.is_E (Type Term) Term)
(declare-fun Prims.is_E@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 399
(Term_constr_id Prims.is_E@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_E@tok
@a0)
@x1)
(Prims.is_E @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_E@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_E@tok
Typ_fun_394))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.result @a0)))
(HasType (Prims.is_E @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_E @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_E @a0
@x1)
(BoxBool (is-Prims.E @x1)))
  
:pattern ((Prims.is_E @a0
@x1)))))

; </end encoding Prims.is_E>

; encoding sigelt Prims.is_Err

; <Start encoding Prims.is_Err>
(declare-fun Prims.is_Err (Type Term) Term)
(declare-fun Prims.is_Err@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 401
(Term_constr_id Prims.is_Err@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.is_Err@tok
@a0)
@x1)
(Prims.is_Err @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.is_Err@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_Err@tok
Typ_fun_394))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Prims.result @a0)))
(HasType (Prims.is_Err @a0
@x1)
Prims.bool))
  
:pattern ((Prims.is_Err @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.is_Err @a0
@x1)
(BoxBool (is-Prims.Err @x1)))
  
:pattern ((Prims.is_Err @a0
@x1)))))

; </end encoding Prims.is_Err>

; encoding sigelt Prims.V.a

; <Start encoding Prims.V.a>
(declare-fun Prims.V.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.V.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 405
(Type_constr_id Prims.V.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.V.a@tok
@a0)
@x1)
(Prims.V.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.V.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_402 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_402 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_402 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_149:(result a){(is_V _0_149)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_402 @a2))
(and (HasType @x1
(Prims.result @a2))
(Valid (Prims.b2t (Prims.is_V @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_402 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.V.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_402 @a0)))
(HasKind (Prims.V.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.V.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.V.a @a0
@x1)
(Prims.V_a @x1))
  
:pattern ((Prims.V.a @a0
@x1)))))

; </end encoding Prims.V.a>

; encoding sigelt Prims.V.v

; <Start encoding Prims.V.v>
(declare-fun Prims.V.v (Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_149:(result a){(is_V _0_149)} -> Tot a)
(declare-fun Typ_fun_407 () Type)
;;;;;;;;;;;;;;;;Typ_fun_407 kinding
(assert (HasKind Typ_fun_407
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_407)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_407)))))
;;;;;;;;;;;;;;;;Typ_fun_407 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_407)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Typ_refine_402 @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
@a2))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_407)))))
(declare-fun Prims.V.v@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 410
(Term_constr_id Prims.V.v@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.V.v@tok
@a0)
@x1)
(Prims.V.v @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.V.v@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.V.v@tok
Typ_fun_407))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_402 @a0)))
(HasType (Prims.V.v @a0
@x1)
@a0))
  
:pattern ((Prims.V.v @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.V.v @a0
@x1)
(Prims.V_v @x1))
  
:pattern ((Prims.V.v @a0
@x1)))))

; </end encoding Prims.V.v>

; encoding sigelt Prims.E.a

; <Start encoding Prims.E.a>
(declare-fun Prims.E.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.E.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 414
(Type_constr_id Prims.E.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.E.a@tok
@a0)
@x1)
(Prims.E.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.E.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_411 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_411 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_411 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_151:(result a){(is_E _0_151)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_411 @a2))
(and (HasType @x1
(Prims.result @a2))
(Valid (Prims.b2t (Prims.is_E @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_411 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.E.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_411 @a0)))
(HasKind (Prims.E.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.E.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.E.a @a0
@x1)
(Prims.E_a @x1))
  
:pattern ((Prims.E.a @a0
@x1)))))

; </end encoding Prims.E.a>

; encoding sigelt Prims.E.e

; <Start encoding Prims.E.e>
(declare-fun Prims.E.e (Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_151:(result a){(is_E _0_151)} -> Tot exn)
(declare-fun Typ_fun_416 () Type)
;;;;;;;;;;;;;;;;Typ_fun_416 kinding
(assert (HasKind Typ_fun_416
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_416)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_416)))))
;;;;;;;;;;;;;;;;Typ_fun_416 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_416)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Typ_refine_411 @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.exn))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_416)))))
(declare-fun Prims.E.e@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 419
(Term_constr_id Prims.E.e@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.E.e@tok
@a0)
@x1)
(Prims.E.e @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.E.e@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.E.e@tok
Typ_fun_416))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_411 @a0)))
(HasType (Prims.E.e @a0
@x1)
Prims.exn))
  
:pattern ((Prims.E.e @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.E.e @a0
@x1)
(Prims.E_e @x1))
  
:pattern ((Prims.E.e @a0
@x1)))))

; </end encoding Prims.E.e>

; encoding sigelt Prims.Err.a

; <Start encoding Prims.Err.a>
(declare-fun Prims.Err.a (Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Err.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 423
(Type_constr_id Prims.Err.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyTE (ApplyTT Prims.Err.a@tok
@a0)
@x1)
(Prims.Err.a @a0
@x1))
  
:pattern ((ApplyTE (ApplyTT Prims.Err.a@tok
@a0)
@x1)))))
(declare-fun Typ_refine_420 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_420 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_420 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;_0_153:(result a){(is_Err _0_153)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_420 @a2))
(and (HasType @x1
(Prims.result @a2))
(Valid (Prims.b2t (Prims.is_Err @a2
@x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_420 @a2))))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Err.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_420 @a0)))
(HasKind (Prims.Err.a @a0
@x1)
Kind_type))
  
:pattern ((Prims.Err.a @a0
@x1)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Err.a @a0
@x1)
(Prims.Err_a @x1))
  
:pattern ((Prims.Err.a @a0
@x1)))))

; </end encoding Prims.Err.a>

; encoding sigelt Prims.Err.msg

; <Start encoding Prims.Err.msg>
(declare-fun Prims.Err.msg (Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:_0_153:(result a){(is_Err _0_153)} -> Tot string)
(declare-fun Typ_fun_425 () Type)
;;;;;;;;;;;;;;;;Typ_fun_425 kinding
(assert (HasKind Typ_fun_425
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_425)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_425)))))
;;;;;;;;;;;;;;;;Typ_fun_425 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_425)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
(Typ_refine_420 @a2)))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.string))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_425)))))
(declare-fun Prims.Err.msg@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 428
(Term_constr_id Prims.Err.msg@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.Err.msg@tok
@a0)
@x1)
(Prims.Err.msg @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.Err.msg@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.Err.msg@tok
Typ_fun_425))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
(Typ_refine_420 @a0)))
(HasType (Prims.Err.msg @a0
@x1)
Prims.string))
  
:pattern ((Prims.Err.msg @a0
@x1)))))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (Prims.Err.msg @a0
@x1)
(Prims.Err_msg @x1))
  
:pattern ((Prims.Err.msg @a0
@x1)))))

; </end encoding Prims.Err.msg>

; encoding sigelt Prims.DIV

; <Skipped Prims.DIV/>

; encoding sigelt Prims.Div

; <Skipped Prims.Div/>

; encoding sigelt Prims.Dv

; <Skipped Prims.Dv/>

; encoding sigelt Prims.STPre_h

; <Skipped Prims.STPre_h/>

; encoding sigelt Prims.STPost_h

; <Skipped Prims.STPost_h/>

; encoding sigelt Prims.STWP_h

; <Skipped Prims.STWP_h/>

; encoding sigelt Prims.st_return

; <Skipped Prims.st_return/>

; encoding sigelt Prims.st_bind_wp

; <Skipped Prims.st_bind_wp/>

; encoding sigelt Prims.st_bind_wlp

; <Skipped Prims.st_bind_wlp/>

; encoding sigelt Prims.st_if_then_else

; <Skipped Prims.st_if_then_else/>

; encoding sigelt Prims.st_ite_wlp

; <Skipped Prims.st_ite_wlp/>

; encoding sigelt Prims.st_ite_wp

; <Skipped Prims.st_ite_wp/>

; encoding sigelt Prims.st_wp_binop

; <Skipped Prims.st_wp_binop/>

; encoding sigelt Prims.st_wp_as_type

; <Skipped Prims.st_wp_as_type/>

; encoding sigelt Prims.st_close_wp

; <Skipped Prims.st_close_wp/>

; encoding sigelt Prims.st_close_wp_t

; <Skipped Prims.st_close_wp_t/>

; encoding sigelt Prims.st_assert_p

; <Skipped Prims.st_assert_p/>

; encoding sigelt Prims.st_assume_p

; <Skipped Prims.st_assume_p/>

; encoding sigelt Prims.st_null_wp

; <Skipped Prims.st_null_wp/>

; encoding sigelt Prims.st_trivial

; <Skipped Prims.st_trivial/>

; encoding sigelt Prims.STATE_h

; <Skipped Prims.STATE_h/>

; encoding sigelt Prims.heap

; <Start encoding Prims.heap>

; <start constructor Prims.heap>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.heap () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 429
(Type_constr_id Prims.heap)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.heap ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
429)
(= @a0
Prims.heap)))

; </end constructor Prims.heap>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.heap
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.heap)
(= Prims.heap
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.heap)))))

; </end encoding Prims.heap>

; encoding sigelt Prims.STPre

; <Skipped Prims.STPre/>

; encoding sigelt Prims.STPost

; <Skipped Prims.STPost/>

; encoding sigelt Prims.STWP

; <Skipped Prims.STWP/>

; encoding sigelt Prims.STATE

; <Skipped Prims.STATE/>

; encoding sigelt Prims.State

; <Skipped Prims.State/>

; encoding sigelt Prims.ST

; <Skipped Prims.ST/>

; encoding sigelt Prims.St

; <Skipped Prims.St/>

; encoding sigelt Prims.ExPre

; <Skipped Prims.ExPre/>

; encoding sigelt Prims.ExPost

; <Skipped Prims.ExPost/>

; encoding sigelt Prims.ExWP

; <Skipped Prims.ExWP/>

; encoding sigelt Prims.ex_return

; <Skipped Prims.ex_return/>

; encoding sigelt Prims.ex_bind_wlp

; <Skipped Prims.ex_bind_wlp/>

; encoding sigelt Prims.ex_bind_wp

; <Skipped Prims.ex_bind_wp/>

; encoding sigelt Prims.ex_if_then_else

; <Skipped Prims.ex_if_then_else/>

; encoding sigelt Prims.ex_ite_wlp

; <Skipped Prims.ex_ite_wlp/>

; encoding sigelt Prims.ex_ite_wp

; <Skipped Prims.ex_ite_wp/>

; encoding sigelt Prims.ex_wp_binop

; <Skipped Prims.ex_wp_binop/>

; encoding sigelt Prims.ex_wp_as_type

; <Skipped Prims.ex_wp_as_type/>

; encoding sigelt Prims.ex_close_wp

; <Skipped Prims.ex_close_wp/>

; encoding sigelt Prims.ex_close_wp_t

; <Skipped Prims.ex_close_wp_t/>

; encoding sigelt Prims.ex_assert_p

; <Skipped Prims.ex_assert_p/>

; encoding sigelt Prims.ex_assume_p

; <Skipped Prims.ex_assume_p/>

; encoding sigelt Prims.ex_null_wp

; <Skipped Prims.ex_null_wp/>

; encoding sigelt Prims.ex_trivial

; <Skipped Prims.ex_trivial/>

; encoding sigelt Prims.EXN

; <Skipped Prims.EXN/>

; encoding sigelt Prims.Exn

; <Skipped Prims.Exn/>

; encoding sigelt Prims.Ex

; <Skipped Prims.Ex/>

; encoding sigelt Prims.AllPre_h

; <Skipped Prims.AllPre_h/>

; encoding sigelt Prims.AllPost_h

; <Skipped Prims.AllPost_h/>

; encoding sigelt Prims.AllWP_h

; <Skipped Prims.AllWP_h/>

; encoding sigelt Prims.all_return

; <Skipped Prims.all_return/>

; encoding sigelt Prims.all_bind_wp

; <Skipped Prims.all_bind_wp/>

; encoding sigelt Prims.all_bind_wlp

; <Skipped Prims.all_bind_wlp/>

; encoding sigelt Prims.all_if_then_else

; <Skipped Prims.all_if_then_else/>

; encoding sigelt Prims.all_ite_wlp

; <Skipped Prims.all_ite_wlp/>

; encoding sigelt Prims.all_ite_wp

; <Skipped Prims.all_ite_wp/>

; encoding sigelt Prims.all_wp_binop

; <Skipped Prims.all_wp_binop/>

; encoding sigelt Prims.all_wp_as_type

; <Skipped Prims.all_wp_as_type/>

; encoding sigelt Prims.all_close_wp

; <Skipped Prims.all_close_wp/>

; encoding sigelt Prims.all_close_wp_t

; <Skipped Prims.all_close_wp_t/>

; encoding sigelt Prims.all_assert_p

; <Skipped Prims.all_assert_p/>

; encoding sigelt Prims.all_assume_p

; <Skipped Prims.all_assume_p/>

; encoding sigelt Prims.all_null_wp

; <Skipped Prims.all_null_wp/>

; encoding sigelt Prims.all_trivial

; <Skipped Prims.all_trivial/>

; encoding sigelt Prims.ALL_h

; <Skipped Prims.ALL_h/>

; encoding sigelt Prims.AllPre

; <Skipped Prims.AllPre/>

; encoding sigelt Prims.AllPost

; <Skipped Prims.AllPost/>

; encoding sigelt Prims.AllWP

; <Skipped Prims.AllWP/>

; encoding sigelt Prims.ALL

; <Skipped Prims.ALL/>

; encoding sigelt Prims.All

; <Skipped Prims.All/>

; encoding sigelt Prims.ML

; <Skipped Prims.ML/>

; encoding sigelt 

; <Skipped />

; encoding sigelt 

; <Skipped />

; encoding sigelt 

; <Skipped />

; encoding sigelt 

; <Skipped />

; encoding sigelt 

; <Skipped />

; encoding sigelt Prims.lex_t, Prims.LexTop, Prims.LexCons

; <Start encoding >

; <Start encoding Prims.lex_t>

; <start constructor Prims.lex_t>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.lex_t () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 444
(Type_constr_id Prims.lex_t)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.lex_t ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
444)
(= @a0
Prims.lex_t)))

; </end constructor Prims.lex_t>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Prims.lex_t
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Prims.lex_t)
(= Prims.lex_t
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Prims.lex_t)))))

; </end encoding Prims.lex_t>

; <Start encoding Prims.LexTop>

; <start constructor Prims.LexTop>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.LexTop () Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 450
(Term_constr_id Prims.LexTop)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.LexTop ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
450)
(= @x0
Prims.LexTop)))

; </end constructor Prims.LexTop>
;;;;;;;;;;;;;;;;data constructor proxy: LexTop
(declare-fun Prims.LexTop@tok () Term)
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.LexTop@tok
Prims.lex_t))
;;;;;;;;;;;;;;;;equality for proxy
(assert (= Prims.LexTop@tok
Prims.LexTop))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel))
 (! (HasTypeFuel @u0
Prims.LexTop
Prims.lex_t)
  
:pattern ((HasTypeFuel @u0
Prims.LexTop
Prims.lex_t)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert true)
;;;;;;;;;;;;;;;;lextop is top
(assert (forall ((@x0 Term))
 (! (implies (is-LexCons @x0)
(Valid (Precedes @x0
Prims.LexTop)))
  
:pattern ((Valid (Precedes @x0
Prims.LexTop))))))

; </end encoding Prims.LexTop>

; <Skipped Prims.LexCons/>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Prims.lex_t)
(or (is-Prims.LexTop @x1)
(is-Prims.LexCons @x1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
Prims.lex_t)))))

; </end encoding >

; encoding sigelt Prims.is_LexTop

; <Start encoding Prims.is_LexTop>
(declare-fun Prims.is_LexTop (Term) Term)
;;;;;;;;;;;;;;;;(lex_t -> Tot bool)
(declare-fun Typ_fun_453 () Type)
;;;;;;;;;;;;;;;;Typ_fun_453 kinding
(assert (HasKind Typ_fun_453
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_453)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_453)))))
;;;;;;;;;;;;;;;;Typ_fun_453 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_453)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Prims.lex_t)
(HasType (ApplyEE @x1
@x2)
Prims.bool))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_453)))))
(declare-fun Prims.is_LexTop@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 456
(Term_constr_id Prims.is_LexTop@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Prims.is_LexTop@tok
@x0)
(Prims.is_LexTop @x0))
  
:pattern ((ApplyEE Prims.is_LexTop@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_LexTop@tok
Typ_fun_453))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.lex_t)
(HasType (Prims.is_LexTop @x0)
Prims.bool))
  
:pattern ((Prims.is_LexTop @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Prims.is_LexTop @x0)
(BoxBool (is-Prims.LexTop @x0)))
  
:pattern ((Prims.is_LexTop @x0)))))

; </end encoding Prims.is_LexTop>

; encoding sigelt Prims.is_LexCons

; <Start encoding Prims.is_LexCons>
(declare-fun Prims.is_LexCons (Term) Term)
(declare-fun Prims.is_LexCons@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 458
(Term_constr_id Prims.is_LexCons@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Prims.is_LexCons@tok
@x0)
(Prims.is_LexCons @x0))
  
:pattern ((ApplyEE Prims.is_LexCons@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_LexCons@tok
Typ_fun_453))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.lex_t)
(HasType (Prims.is_LexCons @x0)
Prims.bool))
  
:pattern ((Prims.is_LexCons @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Prims.is_LexCons @x0)
(BoxBool (is-Prims.LexCons @x0)))
  
:pattern ((Prims.is_LexCons @x0)))))

; </end encoding Prims.is_LexCons>

; encoding sigelt Prims.Tuple2, Prims.MkTuple2

; <Start encoding >

; <Start encoding Prims.Tuple2>

; <start constructor Prims.Tuple2>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple2 (Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type))
 (= 470
(Type_constr_id (Prims.Tuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple2@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.Tuple2@a0 (Prims.Tuple2 @a0
@a1))
@a0)
  
:pattern ((Prims.Tuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple2@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.Tuple2@a1 (Prims.Tuple2 @a0
@a1))
@a1)
  
:pattern ((Prims.Tuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple2 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
470)
(= @a0
(Prims.Tuple2 (Prims.Tuple2@a0 @a0)
(Prims.Tuple2@a1 @a0)))))

; </end constructor Prims.Tuple2>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple2@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 471
(Type_constr_id Prims.Tuple2@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.Tuple2@tok
@a0)
@a1)
(Prims.Tuple2 @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.Tuple2@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple2@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type))
(HasKind (Prims.Tuple2 @a0
@a1)
Kind_type))
  
:pattern ((Prims.Tuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple2 @a2
@a3))
(= (Prims.Tuple2 @a2
@a3)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple2 @a2
@a3))))))

; </end encoding Prims.Tuple2>

; <Start encoding Prims.MkTuple2>

; <start constructor Prims.MkTuple2>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple2 (Type Type Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (= 477
(Term_constr_id (Prims.MkTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple2__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkTuple2__a (Prims.MkTuple2 @a0
@a1
@x2
@x3))
@a0)
  
:pattern ((Prims.MkTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple2__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkTuple2__b (Prims.MkTuple2 @a0
@a1
@x2
@x3))
@a1)
  
:pattern ((Prims.MkTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple2__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkTuple2__1 (Prims.MkTuple2 @a0
@a1
@x2
@x3))
@x2)
  
:pattern ((Prims.MkTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple2__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkTuple2__2 (Prims.MkTuple2 @a0
@a1
@x2
@x3))
@x3)
  
:pattern ((Prims.MkTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple2 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
477)
(= @x0
(Prims.MkTuple2 (Prims.MkTuple2__a @x0)
(Prims.MkTuple2__b @x0)
(Prims.MkTuple2__1 @x0)
(Prims.MkTuple2__2 @x0)))))

; </end constructor Prims.MkTuple2>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> Tot (Tuple2 'a 'b))
(declare-fun Typ_fun_479 () Type)
;;;;;;;;;;;;;;;;Typ_fun_479 kinding
(assert (HasKind Typ_fun_479
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_479)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_479)))))
;;;;;;;;;;;;;;;;Typ_fun_479 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_479)
(forall ((@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
@a2)
(HasType @x5
@a3))
(HasType (ApplyEE (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@x5)
(Prims.Tuple2 @a2
@a3)))
  
:pattern ((ApplyEE (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_479)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple2
(declare-fun Prims.MkTuple2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 482
(Term_constr_id Prims.MkTuple2@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple2@tok
Typ_fun_479))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (ApplyEE (ApplyEE (ApplyET (ApplyET Prims.MkTuple2@tok
@a0)
@a1)
@x2)
@x3)
(Prims.MkTuple2 @a0
@a1
@x2
@x3))
  
:pattern ((ApplyEE (ApplyEE (ApplyET (ApplyET Prims.MkTuple2@tok
@a0)
@a1)
@x2)
@x3)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasTypeFuel (SFuel @u0)
@x3
@a1)
(HasTypeFuel (SFuel @u0)
@x4
@a2))
(HasTypeFuel @u0
(Prims.MkTuple2 @a1
@a2
@x3
@x4)
(Prims.Tuple2 @a1
@a2)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple2 @a1
@a2
@x3
@x4)
(Prims.Tuple2 @a1
@a2))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@a5 Type) (@a6 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple2 @a1
@a2
@x3
@x4)
(Prims.Tuple2 @a5
@a6))
(and (= @a2
@a6)
(= @a1
@a5)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasTypeFuel @u0
@x3
@a1)
(HasTypeFuel @u0
@x4
@a2)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple2 @a1
@a2
@x3
@x4)
(Prims.Tuple2 @a5
@a6))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@a5 Type) (@a6 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple2 @a1
@a2
@x3
@x4)
(Prims.Tuple2 @a5
@a6))
(and (Valid (Precedes @x3
(Prims.MkTuple2 @a1
@a2
@x3
@x4)))
(Valid (Precedes @x4
(Prims.MkTuple2 @a1
@a2
@x3
@x4)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple2 @a1
@a2
@x3
@x4)
(Prims.Tuple2 @a5
@a6))))))

; </end encoding Prims.MkTuple2>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple2 @a2
@a3))
(and (is-Prims.MkTuple2 @x1)
(= @a2
(Prims.MkTuple2__a @x1))
(= @a3
(Prims.MkTuple2__b @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple2 @a2
@a3))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple2

; <Start encoding Prims.is_MkTuple2>
(declare-fun Prims.is_MkTuple2 (Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple2 'a 'b) -> Tot bool)
(declare-fun Typ_fun_484 () Type)
;;;;;;;;;;;;;;;;Typ_fun_484 kinding
(assert (HasKind Typ_fun_484
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_484)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_484)))))
;;;;;;;;;;;;;;;;Typ_fun_484 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_484)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple2 @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_484)))))
(declare-fun Prims.is_MkTuple2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 487
(Term_constr_id Prims.is_MkTuple2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.is_MkTuple2@tok
@a0)
@a1)
@x2)
(Prims.is_MkTuple2 @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.is_MkTuple2@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple2@tok
Typ_fun_484))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(HasType (Prims.is_MkTuple2 @a0
@a1
@x2)
Prims.bool))
  
:pattern ((Prims.is_MkTuple2 @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.is_MkTuple2 @a0
@a1
@x2)
(BoxBool (is-Prims.MkTuple2 @x2)))
  
:pattern ((Prims.is_MkTuple2 @a0
@a1
@x2)))))

; </end encoding Prims.is_MkTuple2>

; encoding sigelt Prims.MkTuple2.'a

; <Start encoding Prims.MkTuple2.'a>
(declare-fun Prims.MkTuple2._a (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple2._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 489
(Type_constr_id Prims.MkTuple2._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.MkTuple2._a@tok
@a0)
@a1)
@x2)
(Prims.MkTuple2._a @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.MkTuple2._a@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple2._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(HasKind (Prims.MkTuple2._a @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.MkTuple2._a @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkTuple2._a @a0
@a1
@x2)
(Prims.MkTuple2__a @x2))
  
:pattern ((Prims.MkTuple2._a @a0
@a1
@x2)))))

; </end encoding Prims.MkTuple2.'a>

; encoding sigelt Prims.MkTuple2.'b

; <Start encoding Prims.MkTuple2.'b>
(declare-fun Prims.MkTuple2._b (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple2._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 491
(Type_constr_id Prims.MkTuple2._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.MkTuple2._b@tok
@a0)
@a1)
@x2)
(Prims.MkTuple2._b @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.MkTuple2._b@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple2._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(HasKind (Prims.MkTuple2._b @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.MkTuple2._b @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkTuple2._b @a0
@a1
@x2)
(Prims.MkTuple2__b @x2))
  
:pattern ((Prims.MkTuple2._b @a0
@a1
@x2)))))

; </end encoding Prims.MkTuple2.'b>

; encoding sigelt Prims.MkTuple2._1

; <Start encoding Prims.MkTuple2._1>
(declare-fun Prims.MkTuple2._1 (Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple2 'a 'b) -> Tot 'a)
(declare-fun Typ_fun_493 () Type)
;;;;;;;;;;;;;;;;Typ_fun_493 kinding
(assert (HasKind Typ_fun_493
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_493)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_493)))))
;;;;;;;;;;;;;;;;Typ_fun_493 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_493)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple2 @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_493)))))
(declare-fun Prims.MkTuple2._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 496
(Term_constr_id Prims.MkTuple2._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.MkTuple2._1@tok
@a0)
@a1)
@x2)
(Prims.MkTuple2._1 @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.MkTuple2._1@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple2._1@tok
Typ_fun_493))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(HasType (Prims.MkTuple2._1 @a0
@a1
@x2)
@a0))
  
:pattern ((Prims.MkTuple2._1 @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkTuple2._1 @a0
@a1
@x2)
(Prims.MkTuple2__1 @x2))
  
:pattern ((Prims.MkTuple2._1 @a0
@a1
@x2)))))

; </end encoding Prims.MkTuple2._1>

; encoding sigelt Prims.MkTuple2._2

; <Start encoding Prims.MkTuple2._2>
(declare-fun Prims.MkTuple2._2 (Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple2 'a 'b) -> Tot 'b)
(declare-fun Typ_fun_498 () Type)
;;;;;;;;;;;;;;;;Typ_fun_498 kinding
(assert (HasKind Typ_fun_498
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_498)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_498)))))
;;;;;;;;;;;;;;;;Typ_fun_498 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_498)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple2 @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_498)))))
(declare-fun Prims.MkTuple2._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 501
(Term_constr_id Prims.MkTuple2._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.MkTuple2._2@tok
@a0)
@a1)
@x2)
(Prims.MkTuple2._2 @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.MkTuple2._2@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple2._2@tok
Typ_fun_498))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(HasType (Prims.MkTuple2._2 @a0
@a1
@x2)
@a1))
  
:pattern ((Prims.MkTuple2._2 @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkTuple2._2 @a0
@a1
@x2)
(Prims.MkTuple2__2 @x2))
  
:pattern ((Prims.MkTuple2._2 @a0
@a1
@x2)))))

; </end encoding Prims.MkTuple2._2>

; encoding sigelt Prims.Tuple3, Prims.MkTuple3

; <Start encoding >

; <Start encoding Prims.Tuple3>

; <start constructor Prims.Tuple3>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple3 (Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (= 513
(Type_constr_id (Prims.Tuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple3@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (Prims.Tuple3@a0 (Prims.Tuple3 @a0
@a1
@a2))
@a0)
  
:pattern ((Prims.Tuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple3@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (Prims.Tuple3@a1 (Prims.Tuple3 @a0
@a1
@a2))
@a1)
  
:pattern ((Prims.Tuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple3@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (Prims.Tuple3@a2 (Prims.Tuple3 @a0
@a1
@a2))
@a2)
  
:pattern ((Prims.Tuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple3 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
513)
(= @a0
(Prims.Tuple3 (Prims.Tuple3@a0 @a0)
(Prims.Tuple3@a1 @a0)
(Prims.Tuple3@a2 @a0)))))

; </end constructor Prims.Tuple3>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple3@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 514
(Type_constr_id Prims.Tuple3@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.Tuple3@tok
@a0)
@a1)
@a2)
(Prims.Tuple3 @a0
@a1
@a2))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.Tuple3@tok
@a0)
@a1)
@a2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple3@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type))
(HasKind (Prims.Tuple3 @a0
@a1
@a2)
Kind_type))
  
:pattern ((Prims.Tuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple3 @a2
@a3
@a4))
(= (Prims.Tuple3 @a2
@a3
@a4)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple3 @a2
@a3
@a4))))))

; </end encoding Prims.Tuple3>

; <Start encoding Prims.MkTuple3>

; <start constructor Prims.MkTuple3>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple3 (Type Type Type Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (= 520
(Term_constr_id (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple3__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkTuple3__a (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@a0)
  
:pattern ((Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple3__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkTuple3__b (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@a1)
  
:pattern ((Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple3__c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkTuple3__c (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@a2)
  
:pattern ((Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple3__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkTuple3__1 (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@x3)
  
:pattern ((Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple3__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkTuple3__2 (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@x4)
  
:pattern ((Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple3__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkTuple3__3 (Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@x5)
  
:pattern ((Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple3 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
520)
(= @x0
(Prims.MkTuple3 (Prims.MkTuple3__a @x0)
(Prims.MkTuple3__b @x0)
(Prims.MkTuple3__c @x0)
(Prims.MkTuple3__1 @x0)
(Prims.MkTuple3__2 @x0)
(Prims.MkTuple3__3 @x0)))))

; </end constructor Prims.MkTuple3>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> _3:'c -> Tot (Tuple3 'a 'b 'c))
(declare-fun Typ_fun_522 () Type)
;;;;;;;;;;;;;;;;Typ_fun_522 kinding
(assert (HasKind Typ_fun_522
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_522)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_522)))))
;;;;;;;;;;;;;;;;Typ_fun_522 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_522)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
@a2)
(HasType @x6
@a3)
(HasType @x7
@a4))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@x6)
@x7)
(Prims.Tuple3 @a2
@a3
@a4)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@x6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_522)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple3
(declare-fun Prims.MkTuple3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 525
(Term_constr_id Prims.MkTuple3@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple3@tok
Typ_fun_522))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3@tok
@a0)
@a1)
@a2)
@x3)
@x4)
@x5)
(Prims.MkTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3@tok
@a0)
@a1)
@a2)
@x3)
@x4)
@x5)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasTypeFuel (SFuel @u0)
@x4
@a1)
(HasTypeFuel (SFuel @u0)
@x5
@a2)
(HasTypeFuel (SFuel @u0)
@x6
@a3))
(HasTypeFuel @u0
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.Tuple3 @a1
@a2
@a3)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.Tuple3 @a1
@a2
@a3))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@a7 Type) (@a8 Type) (@a9 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.Tuple3 @a7
@a8
@a9))
(and (= @a3
@a9)
(= @a2
@a8)
(= @a1
@a7)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasTypeFuel @u0
@x4
@a1)
(HasTypeFuel @u0
@x5
@a2)
(HasTypeFuel @u0
@x6
@a3)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.Tuple3 @a7
@a8
@a9))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@a7 Type) (@a8 Type) (@a9 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.Tuple3 @a7
@a8
@a9))
(and (Valid (Precedes @x4
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)))
(Valid (Precedes @x5
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)))
(Valid (Precedes @x6
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.Tuple3 @a7
@a8
@a9))))))

; </end encoding Prims.MkTuple3>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple3 @a2
@a3
@a4))
(and (is-Prims.MkTuple3 @x1)
(= @a2
(Prims.MkTuple3__a @x1))
(= @a3
(Prims.MkTuple3__b @x1))
(= @a4
(Prims.MkTuple3__c @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple3 @a2
@a3
@a4))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple3

; <Start encoding Prims.is_MkTuple3>
(declare-fun Prims.is_MkTuple3 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple3 'a 'b 'c) -> Tot bool)
(declare-fun Typ_fun_527 () Type)
;;;;;;;;;;;;;;;;Typ_fun_527 kinding
(assert (HasKind Typ_fun_527
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_527)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_527)))))
;;;;;;;;;;;;;;;;Typ_fun_527 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_527)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_527)))))
(declare-fun Prims.is_MkTuple3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 530
(Term_constr_id Prims.is_MkTuple3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.is_MkTuple3@tok
@a0)
@a1)
@a2)
@x3)
(Prims.is_MkTuple3 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.is_MkTuple3@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple3@tok
Typ_fun_527))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasType (Prims.is_MkTuple3 @a0
@a1
@a2
@x3)
Prims.bool))
  
:pattern ((Prims.is_MkTuple3 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.is_MkTuple3 @a0
@a1
@a2
@x3)
(BoxBool (is-Prims.MkTuple3 @x3)))
  
:pattern ((Prims.is_MkTuple3 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.is_MkTuple3>

; encoding sigelt Prims.MkTuple3.'a

; <Start encoding Prims.MkTuple3.'a>
(declare-fun Prims.MkTuple3._a (Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple3._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 532
(Type_constr_id Prims.MkTuple3._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple3._a@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkTuple3._a @a0
@a1
@a2
@x3))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple3._a@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple3._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasKind (Prims.MkTuple3._a @a0
@a1
@a2
@x3)
Kind_type))
  
:pattern ((Prims.MkTuple3._a @a0
@a1
@a2
@x3)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkTuple3._a @a0
@a1
@a2
@x3)
(Prims.MkTuple3__a @x3))
  
:pattern ((Prims.MkTuple3._a @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkTuple3.'a>

; encoding sigelt Prims.MkTuple3.'b

; <Start encoding Prims.MkTuple3.'b>
(declare-fun Prims.MkTuple3._b (Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple3._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 534
(Type_constr_id Prims.MkTuple3._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple3._b@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkTuple3._b @a0
@a1
@a2
@x3))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple3._b@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple3._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasKind (Prims.MkTuple3._b @a0
@a1
@a2
@x3)
Kind_type))
  
:pattern ((Prims.MkTuple3._b @a0
@a1
@a2
@x3)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkTuple3._b @a0
@a1
@a2
@x3)
(Prims.MkTuple3__b @x3))
  
:pattern ((Prims.MkTuple3._b @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkTuple3.'b>

; encoding sigelt Prims.MkTuple3.'c

; <Start encoding Prims.MkTuple3.'c>
(declare-fun Prims.MkTuple3._c (Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple3._c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 536
(Type_constr_id Prims.MkTuple3._c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple3._c@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkTuple3._c @a0
@a1
@a2
@x3))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple3._c@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple3._c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasKind (Prims.MkTuple3._c @a0
@a1
@a2
@x3)
Kind_type))
  
:pattern ((Prims.MkTuple3._c @a0
@a1
@a2
@x3)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkTuple3._c @a0
@a1
@a2
@x3)
(Prims.MkTuple3__c @x3))
  
:pattern ((Prims.MkTuple3._c @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkTuple3.'c>

; encoding sigelt Prims.MkTuple3._1

; <Start encoding Prims.MkTuple3._1>
(declare-fun Prims.MkTuple3._1 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple3 'a 'b 'c) -> Tot 'a)
(declare-fun Typ_fun_538 () Type)
;;;;;;;;;;;;;;;;Typ_fun_538 kinding
(assert (HasKind Typ_fun_538
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_538)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_538)))))
;;;;;;;;;;;;;;;;Typ_fun_538 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_538)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_538)))))
(declare-fun Prims.MkTuple3._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 541
(Term_constr_id Prims.MkTuple3._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3._1@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkTuple3._1 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3._1@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple3._1@tok
Typ_fun_538))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasType (Prims.MkTuple3._1 @a0
@a1
@a2
@x3)
@a0))
  
:pattern ((Prims.MkTuple3._1 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkTuple3._1 @a0
@a1
@a2
@x3)
(Prims.MkTuple3__1 @x3))
  
:pattern ((Prims.MkTuple3._1 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkTuple3._1>

; encoding sigelt Prims.MkTuple3._2

; <Start encoding Prims.MkTuple3._2>
(declare-fun Prims.MkTuple3._2 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple3 'a 'b 'c) -> Tot 'b)
(declare-fun Typ_fun_543 () Type)
;;;;;;;;;;;;;;;;Typ_fun_543 kinding
(assert (HasKind Typ_fun_543
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_543)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_543)))))
;;;;;;;;;;;;;;;;Typ_fun_543 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_543)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_543)))))
(declare-fun Prims.MkTuple3._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 546
(Term_constr_id Prims.MkTuple3._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3._2@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkTuple3._2 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3._2@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple3._2@tok
Typ_fun_543))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasType (Prims.MkTuple3._2 @a0
@a1
@a2
@x3)
@a1))
  
:pattern ((Prims.MkTuple3._2 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkTuple3._2 @a0
@a1
@a2
@x3)
(Prims.MkTuple3__2 @x3))
  
:pattern ((Prims.MkTuple3._2 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkTuple3._2>

; encoding sigelt Prims.MkTuple3._3

; <Start encoding Prims.MkTuple3._3>
(declare-fun Prims.MkTuple3._3 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple3 'a 'b 'c) -> Tot 'c)
(declare-fun Typ_fun_548 () Type)
;;;;;;;;;;;;;;;;Typ_fun_548 kinding
(assert (HasKind Typ_fun_548
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_548)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_548)))))
;;;;;;;;;;;;;;;;Typ_fun_548 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_548)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@a4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_548)))))
(declare-fun Prims.MkTuple3._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 551
(Term_constr_id Prims.MkTuple3._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3._3@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkTuple3._3 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkTuple3._3@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple3._3@tok
Typ_fun_548))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasType @x3
(Prims.Tuple3 @a0
@a1
@a2)))
(HasType (Prims.MkTuple3._3 @a0
@a1
@a2
@x3)
@a2))
  
:pattern ((Prims.MkTuple3._3 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkTuple3._3 @a0
@a1
@a2
@x3)
(Prims.MkTuple3__3 @x3))
  
:pattern ((Prims.MkTuple3._3 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkTuple3._3>

; encoding sigelt Prims.Tuple4, Prims.MkTuple4

; <Start encoding >

; <Start encoding Prims.Tuple4>

; <start constructor Prims.Tuple4>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple4 (Type Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (= 563
(Type_constr_id (Prims.Tuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple4@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.Tuple4@a0 (Prims.Tuple4 @a0
@a1
@a2
@a3))
@a0)
  
:pattern ((Prims.Tuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple4@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.Tuple4@a1 (Prims.Tuple4 @a0
@a1
@a2
@a3))
@a1)
  
:pattern ((Prims.Tuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple4@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.Tuple4@a2 (Prims.Tuple4 @a0
@a1
@a2
@a3))
@a2)
  
:pattern ((Prims.Tuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple4@a3 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.Tuple4@a3 (Prims.Tuple4 @a0
@a1
@a2
@a3))
@a3)
  
:pattern ((Prims.Tuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple4 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
563)
(= @a0
(Prims.Tuple4 (Prims.Tuple4@a0 @a0)
(Prims.Tuple4@a1 @a0)
(Prims.Tuple4@a2 @a0)
(Prims.Tuple4@a3 @a0)))))

; </end constructor Prims.Tuple4>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple4@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 564
(Type_constr_id Prims.Tuple4@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple4@tok
@a0)
@a1)
@a2)
@a3)
(Prims.Tuple4 @a0
@a1
@a2
@a3))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple4@tok
@a0)
@a1)
@a2)
@a3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple4@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type))
(HasKind (Prims.Tuple4 @a0
@a1
@a2
@a3)
Kind_type))
  
:pattern ((Prims.Tuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple4 @a2
@a3
@a4
@a5))
(= (Prims.Tuple4 @a2
@a3
@a4
@a5)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple4 @a2
@a3
@a4
@a5))))))

; </end encoding Prims.Tuple4>

; <Start encoding Prims.MkTuple4>

; <start constructor Prims.MkTuple4>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple4 (Type Type Type Type Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (= 570
(Term_constr_id (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__a (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a0)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__b (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a1)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__c (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a2)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__d (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__d (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a3)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__1 (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x4)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__2 (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x5)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__3 (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x6)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple4__4 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkTuple4__4 (Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x7)
  
:pattern ((Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple4 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
570)
(= @x0
(Prims.MkTuple4 (Prims.MkTuple4__a @x0)
(Prims.MkTuple4__b @x0)
(Prims.MkTuple4__c @x0)
(Prims.MkTuple4__d @x0)
(Prims.MkTuple4__1 @x0)
(Prims.MkTuple4__2 @x0)
(Prims.MkTuple4__3 @x0)
(Prims.MkTuple4__4 @x0)))))

; </end constructor Prims.MkTuple4>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> _3:'c -> _4:'d -> Tot (Tuple4 'a 'b 'c 'd))
(declare-fun Typ_fun_572 () Type)
;;;;;;;;;;;;;;;;Typ_fun_572 kinding
(assert (HasKind Typ_fun_572
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_572)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_572)))))
;;;;;;;;;;;;;;;;Typ_fun_572 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_572)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
@a2)
(HasType @x7
@a3)
(HasType @x8
@a4)
(HasType @x9
@a5))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@x7)
@x8)
@x9)
(Prims.Tuple4 @a2
@a3
@a4
@a5)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@x7)
@x8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_572)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple4
(declare-fun Prims.MkTuple4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 575
(Term_constr_id Prims.MkTuple4@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple4@tok
Typ_fun_572))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
@x7)
(Prims.MkTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
@x7)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasTypeFuel (SFuel @u0)
@x5
@a1)
(HasTypeFuel (SFuel @u0)
@x6
@a2)
(HasTypeFuel (SFuel @u0)
@x7
@a3)
(HasTypeFuel (SFuel @u0)
@x8
@a4))
(HasTypeFuel @u0
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.Tuple4 @a1
@a2
@a3
@a4)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.Tuple4 @a1
@a2
@a3
@a4))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@a9 Type) (@a10 Type) (@a11 Type) (@a12 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.Tuple4 @a9
@a10
@a11
@a12))
(and (= @a4
@a12)
(= @a3
@a11)
(= @a2
@a10)
(= @a1
@a9)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasTypeFuel @u0
@x5
@a1)
(HasTypeFuel @u0
@x6
@a2)
(HasTypeFuel @u0
@x7
@a3)
(HasTypeFuel @u0
@x8
@a4)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.Tuple4 @a9
@a10
@a11
@a12))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@a9 Type) (@a10 Type) (@a11 Type) (@a12 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.Tuple4 @a9
@a10
@a11
@a12))
(and (Valid (Precedes @x5
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))
(Valid (Precedes @x6
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))
(Valid (Precedes @x7
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))
(Valid (Precedes @x8
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.Tuple4 @a9
@a10
@a11
@a12))))))

; </end encoding Prims.MkTuple4>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple4 @a2
@a3
@a4
@a5))
(and (is-Prims.MkTuple4 @x1)
(= @a2
(Prims.MkTuple4__a @x1))
(= @a3
(Prims.MkTuple4__b @x1))
(= @a4
(Prims.MkTuple4__c @x1))
(= @a5
(Prims.MkTuple4__d @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple4 @a2
@a3
@a4
@a5))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple4

; <Start encoding Prims.is_MkTuple4>
(declare-fun Prims.is_MkTuple4 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple4 'a 'b 'c 'd) -> Tot bool)
(declare-fun Typ_fun_577 () Type)
;;;;;;;;;;;;;;;;Typ_fun_577 kinding
(assert (HasKind Typ_fun_577
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_577)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_577)))))
;;;;;;;;;;;;;;;;Typ_fun_577 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_577)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_577)))))
(declare-fun Prims.is_MkTuple4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 580
(Term_constr_id Prims.is_MkTuple4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.is_MkTuple4 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple4@tok
Typ_fun_577))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.is_MkTuple4 @a0
@a1
@a2
@a3
@x4)
Prims.bool))
  
:pattern ((Prims.is_MkTuple4 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.is_MkTuple4 @a0
@a1
@a2
@a3
@x4)
(BoxBool (is-Prims.MkTuple4 @x4)))
  
:pattern ((Prims.is_MkTuple4 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.is_MkTuple4>

; encoding sigelt Prims.MkTuple4.'a

; <Start encoding Prims.MkTuple4.'a>
(declare-fun Prims.MkTuple4._a (Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple4._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 582
(Type_constr_id Prims.MkTuple4._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._a@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._a @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._a@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple4._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasKind (Prims.MkTuple4._a @a0
@a1
@a2
@a3
@x4)
Kind_type))
  
:pattern ((Prims.MkTuple4._a @a0
@a1
@a2
@a3
@x4)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._a @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__a @x4))
  
:pattern ((Prims.MkTuple4._a @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4.'a>

; encoding sigelt Prims.MkTuple4.'b

; <Start encoding Prims.MkTuple4.'b>
(declare-fun Prims.MkTuple4._b (Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple4._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 584
(Type_constr_id Prims.MkTuple4._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._b@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._b @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._b@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple4._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasKind (Prims.MkTuple4._b @a0
@a1
@a2
@a3
@x4)
Kind_type))
  
:pattern ((Prims.MkTuple4._b @a0
@a1
@a2
@a3
@x4)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._b @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__b @x4))
  
:pattern ((Prims.MkTuple4._b @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4.'b>

; encoding sigelt Prims.MkTuple4.'c

; <Start encoding Prims.MkTuple4.'c>
(declare-fun Prims.MkTuple4._c (Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple4._c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 586
(Type_constr_id Prims.MkTuple4._c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._c@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._c @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._c@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple4._c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasKind (Prims.MkTuple4._c @a0
@a1
@a2
@a3
@x4)
Kind_type))
  
:pattern ((Prims.MkTuple4._c @a0
@a1
@a2
@a3
@x4)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._c @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__c @x4))
  
:pattern ((Prims.MkTuple4._c @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4.'c>

; encoding sigelt Prims.MkTuple4.'d

; <Start encoding Prims.MkTuple4.'d>
(declare-fun Prims.MkTuple4._d (Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple4._d@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 588
(Type_constr_id Prims.MkTuple4._d@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._d@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._d @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple4._d@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple4._d@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasKind (Prims.MkTuple4._d @a0
@a1
@a2
@a3
@x4)
Kind_type))
  
:pattern ((Prims.MkTuple4._d @a0
@a1
@a2
@a3
@x4)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._d @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__d @x4))
  
:pattern ((Prims.MkTuple4._d @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4.'d>

; encoding sigelt Prims.MkTuple4._1

; <Start encoding Prims.MkTuple4._1>
(declare-fun Prims.MkTuple4._1 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple4 'a 'b 'c 'd) -> Tot 'a)
(declare-fun Typ_fun_590 () Type)
;;;;;;;;;;;;;;;;Typ_fun_590 kinding
(assert (HasKind Typ_fun_590
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_590)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_590)))))
;;;;;;;;;;;;;;;;Typ_fun_590 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_590)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_590)))))
(declare-fun Prims.MkTuple4._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 593
(Term_constr_id Prims.MkTuple4._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._1@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._1 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._1@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple4._1@tok
Typ_fun_590))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkTuple4._1 @a0
@a1
@a2
@a3
@x4)
@a0))
  
:pattern ((Prims.MkTuple4._1 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._1 @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__1 @x4))
  
:pattern ((Prims.MkTuple4._1 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4._1>

; encoding sigelt Prims.MkTuple4._2

; <Start encoding Prims.MkTuple4._2>
(declare-fun Prims.MkTuple4._2 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple4 'a 'b 'c 'd) -> Tot 'b)
(declare-fun Typ_fun_595 () Type)
;;;;;;;;;;;;;;;;Typ_fun_595 kinding
(assert (HasKind Typ_fun_595
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_595)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_595)))))
;;;;;;;;;;;;;;;;Typ_fun_595 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_595)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_595)))))
(declare-fun Prims.MkTuple4._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 598
(Term_constr_id Prims.MkTuple4._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._2@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._2 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._2@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple4._2@tok
Typ_fun_595))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkTuple4._2 @a0
@a1
@a2
@a3
@x4)
@a1))
  
:pattern ((Prims.MkTuple4._2 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._2 @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__2 @x4))
  
:pattern ((Prims.MkTuple4._2 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4._2>

; encoding sigelt Prims.MkTuple4._3

; <Start encoding Prims.MkTuple4._3>
(declare-fun Prims.MkTuple4._3 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple4 'a 'b 'c 'd) -> Tot 'c)
(declare-fun Typ_fun_600 () Type)
;;;;;;;;;;;;;;;;Typ_fun_600 kinding
(assert (HasKind Typ_fun_600
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_600)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_600)))))
;;;;;;;;;;;;;;;;Typ_fun_600 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_600)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@a4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_600)))))
(declare-fun Prims.MkTuple4._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 603
(Term_constr_id Prims.MkTuple4._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._3@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._3 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._3@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple4._3@tok
Typ_fun_600))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkTuple4._3 @a0
@a1
@a2
@a3
@x4)
@a2))
  
:pattern ((Prims.MkTuple4._3 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._3 @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__3 @x4))
  
:pattern ((Prims.MkTuple4._3 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4._3>

; encoding sigelt Prims.MkTuple4._4

; <Start encoding Prims.MkTuple4._4>
(declare-fun Prims.MkTuple4._4 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple4 'a 'b 'c 'd) -> Tot 'd)
(declare-fun Typ_fun_605 () Type)
;;;;;;;;;;;;;;;;Typ_fun_605 kinding
(assert (HasKind Typ_fun_605
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_605)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_605)))))
;;;;;;;;;;;;;;;;Typ_fun_605 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_605)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@a5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_605)))))
(declare-fun Prims.MkTuple4._4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 608
(Term_constr_id Prims.MkTuple4._4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkTuple4._4 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple4._4@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple4._4@tok
Typ_fun_605))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasType @x4
(Prims.Tuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkTuple4._4 @a0
@a1
@a2
@a3
@x4)
@a3))
  
:pattern ((Prims.MkTuple4._4 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkTuple4._4 @a0
@a1
@a2
@a3
@x4)
(Prims.MkTuple4__4 @x4))
  
:pattern ((Prims.MkTuple4._4 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkTuple4._4>

; encoding sigelt Prims.Tuple5, Prims.MkTuple5

; <Start encoding >

; <Start encoding Prims.Tuple5>

; <start constructor Prims.Tuple5>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple5 (Type Type Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (= 620
(Type_constr_id (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple5@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (= (Prims.Tuple5@a0 (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4))
@a0)
  
:pattern ((Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple5@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (= (Prims.Tuple5@a1 (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4))
@a1)
  
:pattern ((Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple5@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (= (Prims.Tuple5@a2 (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4))
@a2)
  
:pattern ((Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple5@a3 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (= (Prims.Tuple5@a3 (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4))
@a3)
  
:pattern ((Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple5@a4 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (= (Prims.Tuple5@a4 (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4))
@a4)
  
:pattern ((Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple5 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
620)
(= @a0
(Prims.Tuple5 (Prims.Tuple5@a0 @a0)
(Prims.Tuple5@a1 @a0)
(Prims.Tuple5@a2 @a0)
(Prims.Tuple5@a3 @a0)
(Prims.Tuple5@a4 @a0)))))

; </end constructor Prims.Tuple5>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple5@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 621
(Type_constr_id Prims.Tuple5@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple5@tok
@a0)
@a1)
@a2)
@a3)
@a4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple5@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type))
(HasKind (Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)
Kind_type))
  
:pattern ((Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6))
(= (Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6))))))

; </end encoding Prims.Tuple5>

; <Start encoding Prims.MkTuple5>

; <start constructor Prims.MkTuple5>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple5 (Type Type Type Type Type Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (= 627
(Term_constr_id (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__a (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@a0)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__b (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@a1)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__c (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@a2)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__d (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__d (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@a3)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__e (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__e (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@a4)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__1 (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@x5)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__2 (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@x6)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__3 (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@x7)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__4 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__4 (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@x8)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple5__5 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (Prims.MkTuple5__5 (Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
@x9)
  
:pattern ((Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple5 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
627)
(= @x0
(Prims.MkTuple5 (Prims.MkTuple5__a @x0)
(Prims.MkTuple5__b @x0)
(Prims.MkTuple5__c @x0)
(Prims.MkTuple5__d @x0)
(Prims.MkTuple5__e @x0)
(Prims.MkTuple5__1 @x0)
(Prims.MkTuple5__2 @x0)
(Prims.MkTuple5__3 @x0)
(Prims.MkTuple5__4 @x0)
(Prims.MkTuple5__5 @x0)))))

; </end constructor Prims.MkTuple5>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> _3:'c -> _4:'d -> _5:'e -> Tot (Tuple5 'a 'b 'c 'd 'e))
(declare-fun Typ_fun_629 () Type)
;;;;;;;;;;;;;;;;Typ_fun_629 kinding
(assert (HasKind Typ_fun_629
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_629)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_629)))))
;;;;;;;;;;;;;;;;Typ_fun_629 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_629)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
@a2)
(HasType @x8
@a3)
(HasType @x9
@a4)
(HasType @x10
@a5)
(HasType @x11
@a6))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@x8)
@x9)
@x10)
@x11)
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@x8)
@x9)
@x10)
@x11)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_629)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple5
(declare-fun Prims.MkTuple5@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 632
(Term_constr_id Prims.MkTuple5@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple5@tok
Typ_fun_629))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
@x6)
@x7)
@x8)
@x9)
(Prims.MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8
@x9))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
@x6)
@x7)
@x8)
@x9)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasTypeFuel (SFuel @u0)
@x6
@a1)
(HasTypeFuel (SFuel @u0)
@x7
@a2)
(HasTypeFuel (SFuel @u0)
@x8
@a3)
(HasTypeFuel (SFuel @u0)
@x9
@a4)
(HasTypeFuel (SFuel @u0)
@x10
@a5))
(HasTypeFuel @u0
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)
(Prims.Tuple5 @a1
@a2
@a3
@a4
@a5)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)
(Prims.Tuple5 @a1
@a2
@a3
@a4
@a5))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@a11 Type) (@a12 Type) (@a13 Type) (@a14 Type) (@a15 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)
(Prims.Tuple5 @a11
@a12
@a13
@a14
@a15))
(and (= @a5
@a15)
(= @a4
@a14)
(= @a3
@a13)
(= @a2
@a12)
(= @a1
@a11)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasTypeFuel @u0
@x6
@a1)
(HasTypeFuel @u0
@x7
@a2)
(HasTypeFuel @u0
@x8
@a3)
(HasTypeFuel @u0
@x9
@a4)
(HasTypeFuel @u0
@x10
@a5)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)
(Prims.Tuple5 @a11
@a12
@a13
@a14
@a15))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@a11 Type) (@a12 Type) (@a13 Type) (@a14 Type) (@a15 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)
(Prims.Tuple5 @a11
@a12
@a13
@a14
@a15))
(and (Valid (Precedes @x6
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Precedes @x7
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Precedes @x8
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Precedes @x9
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)))
(Valid (Precedes @x10
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple5 @a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10)
(Prims.Tuple5 @a11
@a12
@a13
@a14
@a15))))))

; </end encoding Prims.MkTuple5>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6))
(and (is-Prims.MkTuple5 @x1)
(= @a2
(Prims.MkTuple5__a @x1))
(= @a3
(Prims.MkTuple5__b @x1))
(= @a4
(Prims.MkTuple5__c @x1))
(= @a5
(Prims.MkTuple5__d @x1))
(= @a6
(Prims.MkTuple5__e @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple5

; <Start encoding Prims.is_MkTuple5>
(declare-fun Prims.is_MkTuple5 (Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple5 'a 'b 'c 'd 'e) -> Tot bool)
(declare-fun Typ_fun_634 () Type)
;;;;;;;;;;;;;;;;Typ_fun_634 kinding
(assert (HasKind Typ_fun_634
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_634)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_634)))))
;;;;;;;;;;;;;;;;Typ_fun_634 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_634)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_634)))))
(declare-fun Prims.is_MkTuple5@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 637
(Term_constr_id Prims.is_MkTuple5@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.is_MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple5@tok
Typ_fun_634))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasType (Prims.is_MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5)
Prims.bool))
  
:pattern ((Prims.is_MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.is_MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5)
(BoxBool (is-Prims.MkTuple5 @x5)))
  
:pattern ((Prims.is_MkTuple5 @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.is_MkTuple5>

; encoding sigelt Prims.MkTuple5.'a

; <Start encoding Prims.MkTuple5.'a>
(declare-fun Prims.MkTuple5._a (Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple5._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 639
(Type_constr_id Prims.MkTuple5._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._a @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple5._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasKind (Prims.MkTuple5._a @a0
@a1
@a2
@a3
@a4
@x5)
Kind_type))
  
:pattern ((Prims.MkTuple5._a @a0
@a1
@a2
@a3
@a4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._a @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__a @x5))
  
:pattern ((Prims.MkTuple5._a @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5.'a>

; encoding sigelt Prims.MkTuple5.'b

; <Start encoding Prims.MkTuple5.'b>
(declare-fun Prims.MkTuple5._b (Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple5._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 641
(Type_constr_id Prims.MkTuple5._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._b @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple5._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasKind (Prims.MkTuple5._b @a0
@a1
@a2
@a3
@a4
@x5)
Kind_type))
  
:pattern ((Prims.MkTuple5._b @a0
@a1
@a2
@a3
@a4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._b @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__b @x5))
  
:pattern ((Prims.MkTuple5._b @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5.'b>

; encoding sigelt Prims.MkTuple5.'c

; <Start encoding Prims.MkTuple5.'c>
(declare-fun Prims.MkTuple5._c (Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple5._c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 643
(Type_constr_id Prims.MkTuple5._c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._c @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple5._c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasKind (Prims.MkTuple5._c @a0
@a1
@a2
@a3
@a4
@x5)
Kind_type))
  
:pattern ((Prims.MkTuple5._c @a0
@a1
@a2
@a3
@a4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._c @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__c @x5))
  
:pattern ((Prims.MkTuple5._c @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5.'c>

; encoding sigelt Prims.MkTuple5.'d

; <Start encoding Prims.MkTuple5.'d>
(declare-fun Prims.MkTuple5._d (Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple5._d@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 645
(Type_constr_id Prims.MkTuple5._d@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._d @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple5._d@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasKind (Prims.MkTuple5._d @a0
@a1
@a2
@a3
@a4
@x5)
Kind_type))
  
:pattern ((Prims.MkTuple5._d @a0
@a1
@a2
@a3
@a4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._d @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__d @x5))
  
:pattern ((Prims.MkTuple5._d @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5.'d>

; encoding sigelt Prims.MkTuple5.'e

; <Start encoding Prims.MkTuple5.'e>
(declare-fun Prims.MkTuple5._e (Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple5._e@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 647
(Type_constr_id Prims.MkTuple5._e@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._e @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple5._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple5._e@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasKind (Prims.MkTuple5._e @a0
@a1
@a2
@a3
@a4
@x5)
Kind_type))
  
:pattern ((Prims.MkTuple5._e @a0
@a1
@a2
@a3
@a4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._e @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__e @x5))
  
:pattern ((Prims.MkTuple5._e @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5.'e>

; encoding sigelt Prims.MkTuple5._1

; <Start encoding Prims.MkTuple5._1>
(declare-fun Prims.MkTuple5._1 (Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple5 'a 'b 'c 'd 'e) -> Tot 'a)
(declare-fun Typ_fun_649 () Type)
;;;;;;;;;;;;;;;;Typ_fun_649 kinding
(assert (HasKind Typ_fun_649
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_649)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_649)))))
;;;;;;;;;;;;;;;;Typ_fun_649 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_649)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_649)))))
(declare-fun Prims.MkTuple5._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 652
(Term_constr_id Prims.MkTuple5._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._1 @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple5._1@tok
Typ_fun_649))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasType (Prims.MkTuple5._1 @a0
@a1
@a2
@a3
@a4
@x5)
@a0))
  
:pattern ((Prims.MkTuple5._1 @a0
@a1
@a2
@a3
@a4
@x5)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._1 @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__1 @x5))
  
:pattern ((Prims.MkTuple5._1 @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5._1>

; encoding sigelt Prims.MkTuple5._2

; <Start encoding Prims.MkTuple5._2>
(declare-fun Prims.MkTuple5._2 (Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple5 'a 'b 'c 'd 'e) -> Tot 'b)
(declare-fun Typ_fun_654 () Type)
;;;;;;;;;;;;;;;;Typ_fun_654 kinding
(assert (HasKind Typ_fun_654
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_654)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_654)))))
;;;;;;;;;;;;;;;;Typ_fun_654 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_654)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_654)))))
(declare-fun Prims.MkTuple5._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 657
(Term_constr_id Prims.MkTuple5._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._2 @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple5._2@tok
Typ_fun_654))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasType (Prims.MkTuple5._2 @a0
@a1
@a2
@a3
@a4
@x5)
@a1))
  
:pattern ((Prims.MkTuple5._2 @a0
@a1
@a2
@a3
@a4
@x5)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._2 @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__2 @x5))
  
:pattern ((Prims.MkTuple5._2 @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5._2>

; encoding sigelt Prims.MkTuple5._3

; <Start encoding Prims.MkTuple5._3>
(declare-fun Prims.MkTuple5._3 (Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple5 'a 'b 'c 'd 'e) -> Tot 'c)
(declare-fun Typ_fun_659 () Type)
;;;;;;;;;;;;;;;;Typ_fun_659 kinding
(assert (HasKind Typ_fun_659
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_659)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_659)))))
;;;;;;;;;;;;;;;;Typ_fun_659 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_659)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@a4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_659)))))
(declare-fun Prims.MkTuple5._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 662
(Term_constr_id Prims.MkTuple5._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._3 @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple5._3@tok
Typ_fun_659))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasType (Prims.MkTuple5._3 @a0
@a1
@a2
@a3
@a4
@x5)
@a2))
  
:pattern ((Prims.MkTuple5._3 @a0
@a1
@a2
@a3
@a4
@x5)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._3 @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__3 @x5))
  
:pattern ((Prims.MkTuple5._3 @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5._3>

; encoding sigelt Prims.MkTuple5._4

; <Start encoding Prims.MkTuple5._4>
(declare-fun Prims.MkTuple5._4 (Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple5 'a 'b 'c 'd 'e) -> Tot 'd)
(declare-fun Typ_fun_664 () Type)
;;;;;;;;;;;;;;;;Typ_fun_664 kinding
(assert (HasKind Typ_fun_664
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_664)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_664)))))
;;;;;;;;;;;;;;;;Typ_fun_664 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_664)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@a5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_664)))))
(declare-fun Prims.MkTuple5._4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 667
(Term_constr_id Prims.MkTuple5._4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._4 @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple5._4@tok
Typ_fun_664))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasType (Prims.MkTuple5._4 @a0
@a1
@a2
@a3
@a4
@x5)
@a3))
  
:pattern ((Prims.MkTuple5._4 @a0
@a1
@a2
@a3
@a4
@x5)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._4 @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__4 @x5))
  
:pattern ((Prims.MkTuple5._4 @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5._4>

; encoding sigelt Prims.MkTuple5._5

; <Start encoding Prims.MkTuple5._5>
(declare-fun Prims.MkTuple5._5 (Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple5 'a 'b 'c 'd 'e) -> Tot 'e)
(declare-fun Typ_fun_669 () Type)
;;;;;;;;;;;;;;;;Typ_fun_669 kinding
(assert (HasKind Typ_fun_669
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_669)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_669)))))
;;;;;;;;;;;;;;;;Typ_fun_669 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_669)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple5 @a2
@a3
@a4
@a5
@a6)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@a6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_669)))))
(declare-fun Prims.MkTuple5._5@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 672
(Term_constr_id Prims.MkTuple5._5@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)
(Prims.MkTuple5._5 @a0
@a1
@a2
@a3
@a4
@x5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple5._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@x5)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple5._5@tok
Typ_fun_669))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasType @x5
(Prims.Tuple5 @a0
@a1
@a2
@a3
@a4)))
(HasType (Prims.MkTuple5._5 @a0
@a1
@a2
@a3
@a4
@x5)
@a4))
  
:pattern ((Prims.MkTuple5._5 @a0
@a1
@a2
@a3
@a4
@x5)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (= (Prims.MkTuple5._5 @a0
@a1
@a2
@a3
@a4
@x5)
(Prims.MkTuple5__5 @x5))
  
:pattern ((Prims.MkTuple5._5 @a0
@a1
@a2
@a3
@a4
@x5)))))

; </end encoding Prims.MkTuple5._5>

; encoding sigelt Prims.Tuple6, Prims.MkTuple6

; <Start encoding >

; <Start encoding Prims.Tuple6>

; <start constructor Prims.Tuple6>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple6 (Type Type Type Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (= 684
(Type_constr_id (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple6@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (Prims.Tuple6@a0 (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
@a0)
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple6@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (Prims.Tuple6@a1 (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
@a1)
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple6@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (Prims.Tuple6@a2 (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
@a2)
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple6@a3 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (Prims.Tuple6@a3 (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
@a3)
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple6@a4 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (Prims.Tuple6@a4 (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
@a4)
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple6@a5 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (Prims.Tuple6@a5 (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
@a5)
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple6 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
684)
(= @a0
(Prims.Tuple6 (Prims.Tuple6@a0 @a0)
(Prims.Tuple6@a1 @a0)
(Prims.Tuple6@a2 @a0)
(Prims.Tuple6@a3 @a0)
(Prims.Tuple6@a4 @a0)
(Prims.Tuple6@a5 @a0)))))

; </end constructor Prims.Tuple6>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple6@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 685
(Type_constr_id Prims.Tuple6@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple6@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type))
(HasKind (Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)
Kind_type))
  
:pattern ((Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7))
(= (Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7))))))

; </end encoding Prims.Tuple6>

; <Start encoding Prims.MkTuple6>

; <start constructor Prims.MkTuple6>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple6 (Type Type Type Type Type Type Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (= 691
(Term_constr_id (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__a (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@a0)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__b (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@a1)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__c (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@a2)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__d (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__d (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@a3)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__e (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__e (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@a4)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__f (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__f (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@a5)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__1 (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@x6)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__2 (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@x7)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__3 (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@x8)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__4 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__4 (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@x9)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__5 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__5 (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@x10)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple6__6 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (Prims.MkTuple6__6 (Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
@x11)
  
:pattern ((Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple6 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
691)
(= @x0
(Prims.MkTuple6 (Prims.MkTuple6__a @x0)
(Prims.MkTuple6__b @x0)
(Prims.MkTuple6__c @x0)
(Prims.MkTuple6__d @x0)
(Prims.MkTuple6__e @x0)
(Prims.MkTuple6__f @x0)
(Prims.MkTuple6__1 @x0)
(Prims.MkTuple6__2 @x0)
(Prims.MkTuple6__3 @x0)
(Prims.MkTuple6__4 @x0)
(Prims.MkTuple6__5 @x0)
(Prims.MkTuple6__6 @x0)))))

; </end constructor Prims.MkTuple6>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> _3:'c -> _4:'d -> _5:'e -> _6:'f -> Tot (Tuple6 'a 'b 'c 'd 'e 'f))
(declare-fun Typ_fun_693 () Type)
;;;;;;;;;;;;;;;;Typ_fun_693 kinding
(assert (HasKind Typ_fun_693
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_693)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_693)))))
;;;;;;;;;;;;;;;;Typ_fun_693 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_693)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
@a2)
(HasType @x9
@a3)
(HasType @x10
@a4)
(HasType @x11
@a5)
(HasType @x12
@a6)
(HasType @x13
@a7))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_693)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple6
(declare-fun Prims.MkTuple6@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 696
(Term_constr_id Prims.MkTuple6@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple6@tok
Typ_fun_693))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)
(Prims.MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6
@x7
@x8
@x9
@x10
@x11))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
@x7)
@x8)
@x9)
@x10)
@x11)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasTypeFuel (SFuel @u0)
@x7
@a1)
(HasTypeFuel (SFuel @u0)
@x8
@a2)
(HasTypeFuel (SFuel @u0)
@x9
@a3)
(HasTypeFuel (SFuel @u0)
@x10
@a4)
(HasTypeFuel (SFuel @u0)
@x11
@a5)
(HasTypeFuel (SFuel @u0)
@x12
@a6))
(HasTypeFuel @u0
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)
(Prims.Tuple6 @a1
@a2
@a3
@a4
@a5
@a6)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)
(Prims.Tuple6 @a1
@a2
@a3
@a4
@a5
@a6))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@a13 Type) (@a14 Type) (@a15 Type) (@a16 Type) (@a17 Type) (@a18 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)
(Prims.Tuple6 @a13
@a14
@a15
@a16
@a17
@a18))
(and (= @a6
@a18)
(= @a5
@a17)
(= @a4
@a16)
(= @a3
@a15)
(= @a2
@a14)
(= @a1
@a13)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasTypeFuel @u0
@x7
@a1)
(HasTypeFuel @u0
@x8
@a2)
(HasTypeFuel @u0
@x9
@a3)
(HasTypeFuel @u0
@x10
@a4)
(HasTypeFuel @u0
@x11
@a5)
(HasTypeFuel @u0
@x12
@a6)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)
(Prims.Tuple6 @a13
@a14
@a15
@a16
@a17
@a18))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@a13 Type) (@a14 Type) (@a15 Type) (@a16 Type) (@a17 Type) (@a18 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)
(Prims.Tuple6 @a13
@a14
@a15
@a16
@a17
@a18))
(and (Valid (Precedes @x7
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Precedes @x8
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Precedes @x9
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Precedes @x10
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Precedes @x11
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)))
(Valid (Precedes @x12
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple6 @a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12)
(Prims.Tuple6 @a13
@a14
@a15
@a16
@a17
@a18))))))

; </end encoding Prims.MkTuple6>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7))
(and (is-Prims.MkTuple6 @x1)
(= @a2
(Prims.MkTuple6__a @x1))
(= @a3
(Prims.MkTuple6__b @x1))
(= @a4
(Prims.MkTuple6__c @x1))
(= @a5
(Prims.MkTuple6__d @x1))
(= @a6
(Prims.MkTuple6__e @x1))
(= @a7
(Prims.MkTuple6__f @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple6

; <Start encoding Prims.is_MkTuple6>
(declare-fun Prims.is_MkTuple6 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple6 'a 'b 'c 'd 'e 'f) -> Tot bool)
(declare-fun Typ_fun_698 () Type)
;;;;;;;;;;;;;;;;Typ_fun_698 kinding
(assert (HasKind Typ_fun_698
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_698)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_698)))))
;;;;;;;;;;;;;;;;Typ_fun_698 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_698)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_698)))))
(declare-fun Prims.is_MkTuple6@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 701
(Term_constr_id Prims.is_MkTuple6@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.is_MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple6@tok
Typ_fun_698))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.is_MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Prims.bool))
  
:pattern ((Prims.is_MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.is_MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(BoxBool (is-Prims.MkTuple6 @x6)))
  
:pattern ((Prims.is_MkTuple6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.is_MkTuple6>

; encoding sigelt Prims.MkTuple6.'a

; <Start encoding Prims.MkTuple6.'a>
(declare-fun Prims.MkTuple6._a (Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple6._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 703
(Type_constr_id Prims.MkTuple6._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._a @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple6._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasKind (Prims.MkTuple6._a @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Kind_type))
  
:pattern ((Prims.MkTuple6._a @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._a @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__a @x6))
  
:pattern ((Prims.MkTuple6._a @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6.'a>

; encoding sigelt Prims.MkTuple6.'b

; <Start encoding Prims.MkTuple6.'b>
(declare-fun Prims.MkTuple6._b (Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple6._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 705
(Type_constr_id Prims.MkTuple6._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._b @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple6._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasKind (Prims.MkTuple6._b @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Kind_type))
  
:pattern ((Prims.MkTuple6._b @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._b @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__b @x6))
  
:pattern ((Prims.MkTuple6._b @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6.'b>

; encoding sigelt Prims.MkTuple6.'c

; <Start encoding Prims.MkTuple6.'c>
(declare-fun Prims.MkTuple6._c (Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple6._c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 707
(Type_constr_id Prims.MkTuple6._c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._c @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple6._c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasKind (Prims.MkTuple6._c @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Kind_type))
  
:pattern ((Prims.MkTuple6._c @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._c @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__c @x6))
  
:pattern ((Prims.MkTuple6._c @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6.'c>

; encoding sigelt Prims.MkTuple6.'d

; <Start encoding Prims.MkTuple6.'d>
(declare-fun Prims.MkTuple6._d (Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple6._d@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 709
(Type_constr_id Prims.MkTuple6._d@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._d @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple6._d@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasKind (Prims.MkTuple6._d @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Kind_type))
  
:pattern ((Prims.MkTuple6._d @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._d @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__d @x6))
  
:pattern ((Prims.MkTuple6._d @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6.'d>

; encoding sigelt Prims.MkTuple6.'e

; <Start encoding Prims.MkTuple6.'e>
(declare-fun Prims.MkTuple6._e (Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple6._e@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 711
(Type_constr_id Prims.MkTuple6._e@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._e @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple6._e@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasKind (Prims.MkTuple6._e @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Kind_type))
  
:pattern ((Prims.MkTuple6._e @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._e @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__e @x6))
  
:pattern ((Prims.MkTuple6._e @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6.'e>

; encoding sigelt Prims.MkTuple6.'f

; <Start encoding Prims.MkTuple6.'f>
(declare-fun Prims.MkTuple6._f (Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple6._f@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 713
(Type_constr_id Prims.MkTuple6._f@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._f@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._f @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple6._f@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple6._f@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasKind (Prims.MkTuple6._f @a0
@a1
@a2
@a3
@a4
@a5
@x6)
Kind_type))
  
:pattern ((Prims.MkTuple6._f @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._f @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__f @x6))
  
:pattern ((Prims.MkTuple6._f @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6.'f>

; encoding sigelt Prims.MkTuple6._1

; <Start encoding Prims.MkTuple6._1>
(declare-fun Prims.MkTuple6._1 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple6 'a 'b 'c 'd 'e 'f) -> Tot 'a)
(declare-fun Typ_fun_715 () Type)
;;;;;;;;;;;;;;;;Typ_fun_715 kinding
(assert (HasKind Typ_fun_715
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_715)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_715)))))
;;;;;;;;;;;;;;;;Typ_fun_715 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_715)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_715)))))
(declare-fun Prims.MkTuple6._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 718
(Term_constr_id Prims.MkTuple6._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._1 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple6._1@tok
Typ_fun_715))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.MkTuple6._1 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
@a0))
  
:pattern ((Prims.MkTuple6._1 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._1 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__1 @x6))
  
:pattern ((Prims.MkTuple6._1 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6._1>

; encoding sigelt Prims.MkTuple6._2

; <Start encoding Prims.MkTuple6._2>
(declare-fun Prims.MkTuple6._2 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple6 'a 'b 'c 'd 'e 'f) -> Tot 'b)
(declare-fun Typ_fun_720 () Type)
;;;;;;;;;;;;;;;;Typ_fun_720 kinding
(assert (HasKind Typ_fun_720
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_720)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_720)))))
;;;;;;;;;;;;;;;;Typ_fun_720 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_720)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_720)))))
(declare-fun Prims.MkTuple6._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 723
(Term_constr_id Prims.MkTuple6._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._2 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple6._2@tok
Typ_fun_720))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.MkTuple6._2 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
@a1))
  
:pattern ((Prims.MkTuple6._2 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._2 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__2 @x6))
  
:pattern ((Prims.MkTuple6._2 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6._2>

; encoding sigelt Prims.MkTuple6._3

; <Start encoding Prims.MkTuple6._3>
(declare-fun Prims.MkTuple6._3 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple6 'a 'b 'c 'd 'e 'f) -> Tot 'c)
(declare-fun Typ_fun_725 () Type)
;;;;;;;;;;;;;;;;Typ_fun_725 kinding
(assert (HasKind Typ_fun_725
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_725)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_725)))))
;;;;;;;;;;;;;;;;Typ_fun_725 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_725)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@a4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_725)))))
(declare-fun Prims.MkTuple6._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 728
(Term_constr_id Prims.MkTuple6._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._3 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple6._3@tok
Typ_fun_725))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.MkTuple6._3 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
@a2))
  
:pattern ((Prims.MkTuple6._3 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._3 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__3 @x6))
  
:pattern ((Prims.MkTuple6._3 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6._3>

; encoding sigelt Prims.MkTuple6._4

; <Start encoding Prims.MkTuple6._4>
(declare-fun Prims.MkTuple6._4 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple6 'a 'b 'c 'd 'e 'f) -> Tot 'd)
(declare-fun Typ_fun_730 () Type)
;;;;;;;;;;;;;;;;Typ_fun_730 kinding
(assert (HasKind Typ_fun_730
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_730)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_730)))))
;;;;;;;;;;;;;;;;Typ_fun_730 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_730)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@a5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_730)))))
(declare-fun Prims.MkTuple6._4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 733
(Term_constr_id Prims.MkTuple6._4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._4 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple6._4@tok
Typ_fun_730))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.MkTuple6._4 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
@a3))
  
:pattern ((Prims.MkTuple6._4 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._4 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__4 @x6))
  
:pattern ((Prims.MkTuple6._4 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6._4>

; encoding sigelt Prims.MkTuple6._5

; <Start encoding Prims.MkTuple6._5>
(declare-fun Prims.MkTuple6._5 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple6 'a 'b 'c 'd 'e 'f) -> Tot 'e)
(declare-fun Typ_fun_735 () Type)
;;;;;;;;;;;;;;;;Typ_fun_735 kinding
(assert (HasKind Typ_fun_735
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_735)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_735)))))
;;;;;;;;;;;;;;;;Typ_fun_735 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_735)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@a6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_735)))))
(declare-fun Prims.MkTuple6._5@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 738
(Term_constr_id Prims.MkTuple6._5@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._5 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple6._5@tok
Typ_fun_735))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.MkTuple6._5 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
@a4))
  
:pattern ((Prims.MkTuple6._5 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._5 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__5 @x6))
  
:pattern ((Prims.MkTuple6._5 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6._5>

; encoding sigelt Prims.MkTuple6._6

; <Start encoding Prims.MkTuple6._6>
(declare-fun Prims.MkTuple6._6 (Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple6 'a 'b 'c 'd 'e 'f) -> Tot 'f)
(declare-fun Typ_fun_740 () Type)
;;;;;;;;;;;;;;;;Typ_fun_740 kinding
(assert (HasKind Typ_fun_740
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_740)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_740)))))
;;;;;;;;;;;;;;;;Typ_fun_740 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_740)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple6 @a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@a7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_740)))))
(declare-fun Prims.MkTuple6._6@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 743
(Term_constr_id Prims.MkTuple6._6@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkTuple6._6 @a0
@a1
@a2
@a3
@a4
@a5
@x6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple6._6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@x6)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple6._6@tok
Typ_fun_740))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasType @x6
(Prims.Tuple6 @a0
@a1
@a2
@a3
@a4
@a5)))
(HasType (Prims.MkTuple6._6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
@a5))
  
:pattern ((Prims.MkTuple6._6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (= (Prims.MkTuple6._6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)
(Prims.MkTuple6__6 @x6))
  
:pattern ((Prims.MkTuple6._6 @a0
@a1
@a2
@a3
@a4
@a5
@x6)))))

; </end encoding Prims.MkTuple6._6>

; encoding sigelt Prims.Tuple7, Prims.MkTuple7

; <Start encoding >

; <Start encoding Prims.Tuple7>

; <start constructor Prims.Tuple7>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple7 (Type Type Type Type Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (= 755
(Type_constr_id (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a0 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a0)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a1 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a1)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a2 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a2)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a3 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a3 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a3)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a4 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a4 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a4)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a5 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a5 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a5)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple7@a6 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (Prims.Tuple7@a6 (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
@a6)
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple7 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
755)
(= @a0
(Prims.Tuple7 (Prims.Tuple7@a0 @a0)
(Prims.Tuple7@a1 @a0)
(Prims.Tuple7@a2 @a0)
(Prims.Tuple7@a3 @a0)
(Prims.Tuple7@a4 @a0)
(Prims.Tuple7@a5 @a0)
(Prims.Tuple7@a6 @a0)))))

; </end constructor Prims.Tuple7>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple7@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 756
(Type_constr_id Prims.Tuple7@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple7@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type))
(HasKind (Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)
Kind_type))
  
:pattern ((Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8))
(= (Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8))))))

; </end encoding Prims.Tuple7>

; <Start encoding Prims.MkTuple7>

; <start constructor Prims.MkTuple7>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple7 (Type Type Type Type Type Type Type Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (= 762
(Term_constr_id (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__a (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a0)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__b (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a1)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__c (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a2)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__d (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__d (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a3)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__e (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__e (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a4)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__f (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__f (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a5)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__g (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__g (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@a6)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__1 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x7)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__2 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x8)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__3 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x9)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__4 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__4 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x10)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__5 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__5 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x11)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__6 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__6 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x12)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple7__7 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (Prims.MkTuple7__7 (Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
@x13)
  
:pattern ((Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple7 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
762)
(= @x0
(Prims.MkTuple7 (Prims.MkTuple7__a @x0)
(Prims.MkTuple7__b @x0)
(Prims.MkTuple7__c @x0)
(Prims.MkTuple7__d @x0)
(Prims.MkTuple7__e @x0)
(Prims.MkTuple7__f @x0)
(Prims.MkTuple7__g @x0)
(Prims.MkTuple7__1 @x0)
(Prims.MkTuple7__2 @x0)
(Prims.MkTuple7__3 @x0)
(Prims.MkTuple7__4 @x0)
(Prims.MkTuple7__5 @x0)
(Prims.MkTuple7__6 @x0)
(Prims.MkTuple7__7 @x0)))))

; </end constructor Prims.MkTuple7>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> _3:'c -> _4:'d -> _5:'e -> _6:'f -> _7:'g -> Tot (Tuple7 'a 'b 'c 'd 'e 'f 'g))
(declare-fun Typ_fun_764 () Type)
;;;;;;;;;;;;;;;;Typ_fun_764 kinding
(assert (HasKind Typ_fun_764
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_764)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_764)))))
;;;;;;;;;;;;;;;;Typ_fun_764 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_764)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
@a2)
(HasType @x10
@a3)
(HasType @x11
@a4)
(HasType @x12
@a5)
(HasType @x13
@a6)
(HasType @x14
@a7)
(HasType @x15
@a8))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_764)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple7
(declare-fun Prims.MkTuple7@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 767
(Term_constr_id Prims.MkTuple7@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple7@tok
Typ_fun_764))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
(Prims.MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7
@x8
@x9
@x10
@x11
@x12
@x13))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasTypeFuel (SFuel @u0)
@x8
@a1)
(HasTypeFuel (SFuel @u0)
@x9
@a2)
(HasTypeFuel (SFuel @u0)
@x10
@a3)
(HasTypeFuel (SFuel @u0)
@x11
@a4)
(HasTypeFuel (SFuel @u0)
@x12
@a5)
(HasTypeFuel (SFuel @u0)
@x13
@a6)
(HasTypeFuel (SFuel @u0)
@x14
@a7))
(HasTypeFuel @u0
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(Prims.Tuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(Prims.Tuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@a15 Type) (@a16 Type) (@a17 Type) (@a18 Type) (@a19 Type) (@a20 Type) (@a21 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(Prims.Tuple7 @a15
@a16
@a17
@a18
@a19
@a20
@a21))
(and (= @a7
@a21)
(= @a6
@a20)
(= @a5
@a19)
(= @a4
@a18)
(= @a3
@a17)
(= @a2
@a16)
(= @a1
@a15)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasTypeFuel @u0
@x8
@a1)
(HasTypeFuel @u0
@x9
@a2)
(HasTypeFuel @u0
@x10
@a3)
(HasTypeFuel @u0
@x11
@a4)
(HasTypeFuel @u0
@x12
@a5)
(HasTypeFuel @u0
@x13
@a6)
(HasTypeFuel @u0
@x14
@a7)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(Prims.Tuple7 @a15
@a16
@a17
@a18
@a19
@a20
@a21))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@a15 Type) (@a16 Type) (@a17 Type) (@a18 Type) (@a19 Type) (@a20 Type) (@a21 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(Prims.Tuple7 @a15
@a16
@a17
@a18
@a19
@a20
@a21))
(and (Valid (Precedes @x8
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Precedes @x9
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Precedes @x10
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Precedes @x11
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Precedes @x12
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Precedes @x13
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))
(Valid (Precedes @x14
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple7 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14)
(Prims.Tuple7 @a15
@a16
@a17
@a18
@a19
@a20
@a21))))))

; </end encoding Prims.MkTuple7>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8))
(and (is-Prims.MkTuple7 @x1)
(= @a2
(Prims.MkTuple7__a @x1))
(= @a3
(Prims.MkTuple7__b @x1))
(= @a4
(Prims.MkTuple7__c @x1))
(= @a5
(Prims.MkTuple7__d @x1))
(= @a6
(Prims.MkTuple7__e @x1))
(= @a7
(Prims.MkTuple7__f @x1))
(= @a8
(Prims.MkTuple7__g @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple7

; <Start encoding Prims.is_MkTuple7>
(declare-fun Prims.is_MkTuple7 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot bool)
(declare-fun Typ_fun_769 () Type)
;;;;;;;;;;;;;;;;Typ_fun_769 kinding
(assert (HasKind Typ_fun_769
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_769)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_769)))))
;;;;;;;;;;;;;;;;Typ_fun_769 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_769)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_769)))))
(declare-fun Prims.is_MkTuple7@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 772
(Term_constr_id Prims.is_MkTuple7@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.is_MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple7@tok
Typ_fun_769))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.is_MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Prims.bool))
  
:pattern ((Prims.is_MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.is_MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(BoxBool (is-Prims.MkTuple7 @x7)))
  
:pattern ((Prims.is_MkTuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.is_MkTuple7>

; encoding sigelt Prims.MkTuple7.'a

; <Start encoding Prims.MkTuple7.'a>
(declare-fun Prims.MkTuple7._a (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 774
(Type_constr_id Prims.MkTuple7._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__a @x7))
  
:pattern ((Prims.MkTuple7._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'a>

; encoding sigelt Prims.MkTuple7.'b

; <Start encoding Prims.MkTuple7.'b>
(declare-fun Prims.MkTuple7._b (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 776
(Type_constr_id Prims.MkTuple7._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__b @x7))
  
:pattern ((Prims.MkTuple7._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'b>

; encoding sigelt Prims.MkTuple7.'c

; <Start encoding Prims.MkTuple7.'c>
(declare-fun Prims.MkTuple7._c (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 778
(Type_constr_id Prims.MkTuple7._c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__c @x7))
  
:pattern ((Prims.MkTuple7._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'c>

; encoding sigelt Prims.MkTuple7.'d

; <Start encoding Prims.MkTuple7.'d>
(declare-fun Prims.MkTuple7._d (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._d@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 780
(Type_constr_id Prims.MkTuple7._d@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._d@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__d @x7))
  
:pattern ((Prims.MkTuple7._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'d>

; encoding sigelt Prims.MkTuple7.'e

; <Start encoding Prims.MkTuple7.'e>
(declare-fun Prims.MkTuple7._e (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._e@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 782
(Type_constr_id Prims.MkTuple7._e@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._e@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__e @x7))
  
:pattern ((Prims.MkTuple7._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'e>

; encoding sigelt Prims.MkTuple7.'f

; <Start encoding Prims.MkTuple7.'f>
(declare-fun Prims.MkTuple7._f (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._f@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 784
(Type_constr_id Prims.MkTuple7._f@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._f@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._f@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._f@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__f @x7))
  
:pattern ((Prims.MkTuple7._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'f>

; encoding sigelt Prims.MkTuple7.'g

; <Start encoding Prims.MkTuple7.'g>
(declare-fun Prims.MkTuple7._g (Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple7._g@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 786
(Type_constr_id Prims.MkTuple7._g@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._g@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple7._g@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple7._g@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasKind (Prims.MkTuple7._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
Kind_type))
  
:pattern ((Prims.MkTuple7._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__g @x7))
  
:pattern ((Prims.MkTuple7._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7.'g>

; encoding sigelt Prims.MkTuple7._1

; <Start encoding Prims.MkTuple7._1>
(declare-fun Prims.MkTuple7._1 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'a)
(declare-fun Typ_fun_788 () Type)
;;;;;;;;;;;;;;;;Typ_fun_788 kinding
(assert (HasKind Typ_fun_788
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_788)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_788)))))
;;;;;;;;;;;;;;;;Typ_fun_788 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_788)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_788)))))
(declare-fun Prims.MkTuple7._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 791
(Term_constr_id Prims.MkTuple7._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._1@tok
Typ_fun_788))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a0))
  
:pattern ((Prims.MkTuple7._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__1 @x7))
  
:pattern ((Prims.MkTuple7._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._1>

; encoding sigelt Prims.MkTuple7._2

; <Start encoding Prims.MkTuple7._2>
(declare-fun Prims.MkTuple7._2 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'b)
(declare-fun Typ_fun_793 () Type)
;;;;;;;;;;;;;;;;Typ_fun_793 kinding
(assert (HasKind Typ_fun_793
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_793)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_793)))))
;;;;;;;;;;;;;;;;Typ_fun_793 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_793)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_793)))))
(declare-fun Prims.MkTuple7._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 796
(Term_constr_id Prims.MkTuple7._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._2@tok
Typ_fun_793))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a1))
  
:pattern ((Prims.MkTuple7._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__2 @x7))
  
:pattern ((Prims.MkTuple7._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._2>

; encoding sigelt Prims.MkTuple7._3

; <Start encoding Prims.MkTuple7._3>
(declare-fun Prims.MkTuple7._3 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'c)
(declare-fun Typ_fun_798 () Type)
;;;;;;;;;;;;;;;;Typ_fun_798 kinding
(assert (HasKind Typ_fun_798
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_798)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_798)))))
;;;;;;;;;;;;;;;;Typ_fun_798 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_798)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_798)))))
(declare-fun Prims.MkTuple7._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 801
(Term_constr_id Prims.MkTuple7._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._3@tok
Typ_fun_798))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a2))
  
:pattern ((Prims.MkTuple7._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__3 @x7))
  
:pattern ((Prims.MkTuple7._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._3>

; encoding sigelt Prims.MkTuple7._4

; <Start encoding Prims.MkTuple7._4>
(declare-fun Prims.MkTuple7._4 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'd)
(declare-fun Typ_fun_803 () Type)
;;;;;;;;;;;;;;;;Typ_fun_803 kinding
(assert (HasKind Typ_fun_803
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_803)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_803)))))
;;;;;;;;;;;;;;;;Typ_fun_803 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_803)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_803)))))
(declare-fun Prims.MkTuple7._4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 806
(Term_constr_id Prims.MkTuple7._4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._4@tok
Typ_fun_803))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a3))
  
:pattern ((Prims.MkTuple7._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__4 @x7))
  
:pattern ((Prims.MkTuple7._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._4>

; encoding sigelt Prims.MkTuple7._5

; <Start encoding Prims.MkTuple7._5>
(declare-fun Prims.MkTuple7._5 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'e)
(declare-fun Typ_fun_808 () Type)
;;;;;;;;;;;;;;;;Typ_fun_808 kinding
(assert (HasKind Typ_fun_808
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_808)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_808)))))
;;;;;;;;;;;;;;;;Typ_fun_808 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_808)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_808)))))
(declare-fun Prims.MkTuple7._5@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 811
(Term_constr_id Prims.MkTuple7._5@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._5@tok
Typ_fun_808))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a4))
  
:pattern ((Prims.MkTuple7._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__5 @x7))
  
:pattern ((Prims.MkTuple7._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._5>

; encoding sigelt Prims.MkTuple7._6

; <Start encoding Prims.MkTuple7._6>
(declare-fun Prims.MkTuple7._6 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'f)
(declare-fun Typ_fun_813 () Type)
;;;;;;;;;;;;;;;;Typ_fun_813 kinding
(assert (HasKind Typ_fun_813
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_813)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_813)))))
;;;;;;;;;;;;;;;;Typ_fun_813 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_813)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_813)))))
(declare-fun Prims.MkTuple7._6@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 816
(Term_constr_id Prims.MkTuple7._6@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._6@tok
Typ_fun_813))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a5))
  
:pattern ((Prims.MkTuple7._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__6 @x7))
  
:pattern ((Prims.MkTuple7._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._6>

; encoding sigelt Prims.MkTuple7._7

; <Start encoding Prims.MkTuple7._7>
(declare-fun Prims.MkTuple7._7 (Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple7 'a 'b 'c 'd 'e 'f 'g) -> Tot 'g)
(declare-fun Typ_fun_818 () Type)
;;;;;;;;;;;;;;;;Typ_fun_818 kinding
(assert (HasKind Typ_fun_818
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_818)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_818)))))
;;;;;;;;;;;;;;;;Typ_fun_818 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_818)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasType @x9
(Prims.Tuple7 @a2
@a3
@a4
@a5
@a6
@a7
@a8)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)
@a8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_818)))))
(declare-fun Prims.MkTuple7._7@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 821
(Term_constr_id Prims.MkTuple7._7@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)
(Prims.MkTuple7._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple7._7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@x7)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple7._7@tok
Typ_fun_818))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasType @x7
(Prims.Tuple7 @a0
@a1
@a2
@a3
@a4
@a5
@a6)))
(HasType (Prims.MkTuple7._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
@a6))
  
:pattern ((Prims.MkTuple7._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@x7 Term))
 (! (= (Prims.MkTuple7._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)
(Prims.MkTuple7__7 @x7))
  
:pattern ((Prims.MkTuple7._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@x7)))))

; </end encoding Prims.MkTuple7._7>

; encoding sigelt Prims.Tuple8, Prims.MkTuple8

; <Start encoding >

; <Start encoding Prims.Tuple8>

; <start constructor Prims.Tuple8>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.Tuple8 (Type Type Type Type Type Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (= 833
(Type_constr_id (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a0 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a0)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a1 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a1)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a2 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a2)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a3 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a3 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a3)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a4 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a4 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a4)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a5 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a5 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a5)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a6 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a6 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a6)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.Tuple8@a7 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (Prims.Tuple8@a7 (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
@a7)
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.Tuple8 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
833)
(= @a0
(Prims.Tuple8 (Prims.Tuple8@a0 @a0)
(Prims.Tuple8@a1 @a0)
(Prims.Tuple8@a2 @a0)
(Prims.Tuple8@a3 @a0)
(Prims.Tuple8@a4 @a0)
(Prims.Tuple8@a5 @a0)
(Prims.Tuple8@a6 @a0)
(Prims.Tuple8@a7 @a0)))))

; </end constructor Prims.Tuple8>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Tuple8@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 834
(Type_constr_id Prims.Tuple8@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.Tuple8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Tuple8@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type))
(HasKind (Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)
Kind_type))
  
:pattern ((Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9))
(= (Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9))))))

; </end encoding Prims.Tuple8>

; <Start encoding Prims.MkTuple8>

; <start constructor Prims.MkTuple8>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkTuple8 (Type Type Type Type Type Type Type Type Term Term Term Term Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (= 840
(Term_constr_id (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__a (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a0)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__b (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a1)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__c (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a2)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__d (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__d (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a3)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__e (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__e (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a4)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__f (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__f (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a5)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__g (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__g (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a6)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__h (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__h (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@a7)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__1 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x8)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__2 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x9)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__3 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x10)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__4 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__4 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x11)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__5 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__5 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x12)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__6 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__6 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x13)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__7 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__7 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x14)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkTuple8__8 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (Prims.MkTuple8__8 (Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
@x15)
  
:pattern ((Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkTuple8 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
840)
(= @x0
(Prims.MkTuple8 (Prims.MkTuple8__a @x0)
(Prims.MkTuple8__b @x0)
(Prims.MkTuple8__c @x0)
(Prims.MkTuple8__d @x0)
(Prims.MkTuple8__e @x0)
(Prims.MkTuple8__f @x0)
(Prims.MkTuple8__g @x0)
(Prims.MkTuple8__h @x0)
(Prims.MkTuple8__1 @x0)
(Prims.MkTuple8__2 @x0)
(Prims.MkTuple8__3 @x0)
(Prims.MkTuple8__4 @x0)
(Prims.MkTuple8__5 @x0)
(Prims.MkTuple8__6 @x0)
(Prims.MkTuple8__7 @x0)
(Prims.MkTuple8__8 @x0)))))

; </end constructor Prims.MkTuple8>
;;;;;;;;;;;;;;;;(_1:'a -> _2:'b -> _3:'c -> _4:'d -> _5:'e -> _6:'f -> _7:'g -> _8:'h -> Tot (Tuple8 'a 'b 'c 'd 'e 'f 'g 'h))
(declare-fun Typ_fun_842 () Type)
;;;;;;;;;;;;;;;;Typ_fun_842 kinding
(assert (HasKind Typ_fun_842
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_842)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_842)))))
;;;;;;;;;;;;;;;;Typ_fun_842 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_842)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term) (@x16 Term) (@x17 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
@a2)
(HasType @x11
@a3)
(HasType @x12
@a4)
(HasType @x13
@a5)
(HasType @x14
@a6)
(HasType @x15
@a7)
(HasType @x16
@a8)
(HasType @x17
@a9))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
@x16)
@x17)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_842)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkTuple8
(declare-fun Prims.MkTuple8@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 845
(Term_constr_id Prims.MkTuple8@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkTuple8@tok
Typ_fun_842))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)
(Prims.MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8
@x9
@x10
@x11
@x12
@x13
@x14
@x15))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
@x9)
@x10)
@x11)
@x12)
@x13)
@x14)
@x15)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term) (@x16 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasTypeFuel (SFuel @u0)
@x9
@a1)
(HasTypeFuel (SFuel @u0)
@x10
@a2)
(HasTypeFuel (SFuel @u0)
@x11
@a3)
(HasTypeFuel (SFuel @u0)
@x12
@a4)
(HasTypeFuel (SFuel @u0)
@x13
@a5)
(HasTypeFuel (SFuel @u0)
@x14
@a6)
(HasTypeFuel (SFuel @u0)
@x15
@a7)
(HasTypeFuel (SFuel @u0)
@x16
@a8))
(HasTypeFuel @u0
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(Prims.Tuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(Prims.Tuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term) (@x16 Term) (@a17 Type) (@a18 Type) (@a19 Type) (@a20 Type) (@a21 Type) (@a22 Type) (@a23 Type) (@a24 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(Prims.Tuple8 @a17
@a18
@a19
@a20
@a21
@a22
@a23
@a24))
(and (= @a8
@a24)
(= @a7
@a23)
(= @a6
@a22)
(= @a5
@a21)
(= @a4
@a20)
(= @a3
@a19)
(= @a2
@a18)
(= @a1
@a17)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasTypeFuel @u0
@x9
@a1)
(HasTypeFuel @u0
@x10
@a2)
(HasTypeFuel @u0
@x11
@a3)
(HasTypeFuel @u0
@x12
@a4)
(HasTypeFuel @u0
@x13
@a5)
(HasTypeFuel @u0
@x14
@a6)
(HasTypeFuel @u0
@x15
@a7)
(HasTypeFuel @u0
@x16
@a8)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(Prims.Tuple8 @a17
@a18
@a19
@a20
@a21
@a22
@a23
@a24))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@x9 Term) (@x10 Term) (@x11 Term) (@x12 Term) (@x13 Term) (@x14 Term) (@x15 Term) (@x16 Term) (@a17 Type) (@a18 Type) (@a19 Type) (@a20 Type) (@a21 Type) (@a22 Type) (@a23 Type) (@a24 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(Prims.Tuple8 @a17
@a18
@a19
@a20
@a21
@a22
@a23
@a24))
(and (Valid (Precedes @x9
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x10
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x11
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x12
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x13
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x14
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x15
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))
(Valid (Precedes @x16
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkTuple8 @a1
@a2
@a3
@a4
@a5
@a6
@a7
@a8
@x9
@x10
@x11
@x12
@x13
@x14
@x15
@x16)
(Prims.Tuple8 @a17
@a18
@a19
@a20
@a21
@a22
@a23
@a24))))))

; </end encoding Prims.MkTuple8>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9))
(and (is-Prims.MkTuple8 @x1)
(= @a2
(Prims.MkTuple8__a @x1))
(= @a3
(Prims.MkTuple8__b @x1))
(= @a4
(Prims.MkTuple8__c @x1))
(= @a5
(Prims.MkTuple8__d @x1))
(= @a6
(Prims.MkTuple8__e @x1))
(= @a7
(Prims.MkTuple8__f @x1))
(= @a8
(Prims.MkTuple8__g @x1))
(= @a9
(Prims.MkTuple8__h @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9))))))

; </end encoding >

; encoding sigelt Prims.is_MkTuple8

; <Start encoding Prims.is_MkTuple8>
(declare-fun Prims.is_MkTuple8 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot bool)
(declare-fun Typ_fun_847 () Type)
;;;;;;;;;;;;;;;;Typ_fun_847 kinding
(assert (HasKind Typ_fun_847
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_847)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_847)))))
;;;;;;;;;;;;;;;;Typ_fun_847 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_847)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_847)))))
(declare-fun Prims.is_MkTuple8@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 850
(Term_constr_id Prims.is_MkTuple8@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.is_MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkTuple8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkTuple8@tok
Typ_fun_847))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.is_MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Prims.bool))
  
:pattern ((Prims.is_MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.is_MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(BoxBool (is-Prims.MkTuple8 @x8)))
  
:pattern ((Prims.is_MkTuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.is_MkTuple8>

; encoding sigelt Prims.MkTuple8.'a

; <Start encoding Prims.MkTuple8.'a>
(declare-fun Prims.MkTuple8._a (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 852
(Type_constr_id Prims.MkTuple8._a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._a@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__a @x8))
  
:pattern ((Prims.MkTuple8._a @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'a>

; encoding sigelt Prims.MkTuple8.'b

; <Start encoding Prims.MkTuple8.'b>
(declare-fun Prims.MkTuple8._b (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 854
(Type_constr_id Prims.MkTuple8._b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._b@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__b @x8))
  
:pattern ((Prims.MkTuple8._b @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'b>

; encoding sigelt Prims.MkTuple8.'c

; <Start encoding Prims.MkTuple8.'c>
(declare-fun Prims.MkTuple8._c (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 856
(Type_constr_id Prims.MkTuple8._c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._c@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__c @x8))
  
:pattern ((Prims.MkTuple8._c @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'c>

; encoding sigelt Prims.MkTuple8.'d

; <Start encoding Prims.MkTuple8.'d>
(declare-fun Prims.MkTuple8._d (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._d@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 858
(Type_constr_id Prims.MkTuple8._d@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._d@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._d@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__d @x8))
  
:pattern ((Prims.MkTuple8._d @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'d>

; encoding sigelt Prims.MkTuple8.'e

; <Start encoding Prims.MkTuple8.'e>
(declare-fun Prims.MkTuple8._e (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._e@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 860
(Type_constr_id Prims.MkTuple8._e@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._e@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._e@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__e @x8))
  
:pattern ((Prims.MkTuple8._e @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'e>

; encoding sigelt Prims.MkTuple8.'f

; <Start encoding Prims.MkTuple8.'f>
(declare-fun Prims.MkTuple8._f (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._f@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 862
(Type_constr_id Prims.MkTuple8._f@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._f@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._f@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._f@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__f @x8))
  
:pattern ((Prims.MkTuple8._f @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'f>

; encoding sigelt Prims.MkTuple8.'g

; <Start encoding Prims.MkTuple8.'g>
(declare-fun Prims.MkTuple8._g (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._g@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 864
(Type_constr_id Prims.MkTuple8._g@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._g@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._g@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._g@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__g @x8))
  
:pattern ((Prims.MkTuple8._g @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'g>

; encoding sigelt Prims.MkTuple8.'h

; <Start encoding Prims.MkTuple8.'h>
(declare-fun Prims.MkTuple8._h (Type Type Type Type Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkTuple8._h@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 866
(Type_constr_id Prims.MkTuple8._h@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._h@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._h @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkTuple8._h@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkTuple8._h@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasKind (Prims.MkTuple8._h @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
Kind_type))
  
:pattern ((Prims.MkTuple8._h @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._h @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__h @x8))
  
:pattern ((Prims.MkTuple8._h @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8.'h>

; encoding sigelt Prims.MkTuple8._1

; <Start encoding Prims.MkTuple8._1>
(declare-fun Prims.MkTuple8._1 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'a)
(declare-fun Typ_fun_868 () Type)
;;;;;;;;;;;;;;;;Typ_fun_868 kinding
(assert (HasKind Typ_fun_868
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_868)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_868)))))
;;;;;;;;;;;;;;;;Typ_fun_868 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_868)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a2))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_868)))))
(declare-fun Prims.MkTuple8._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 871
(Term_constr_id Prims.MkTuple8._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._1@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._1@tok
Typ_fun_868))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a0))
  
:pattern ((Prims.MkTuple8._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__1 @x8))
  
:pattern ((Prims.MkTuple8._1 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._1>

; encoding sigelt Prims.MkTuple8._2

; <Start encoding Prims.MkTuple8._2>
(declare-fun Prims.MkTuple8._2 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'b)
(declare-fun Typ_fun_873 () Type)
;;;;;;;;;;;;;;;;Typ_fun_873 kinding
(assert (HasKind Typ_fun_873
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_873)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_873)))))
;;;;;;;;;;;;;;;;Typ_fun_873 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_873)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_873)))))
(declare-fun Prims.MkTuple8._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 876
(Term_constr_id Prims.MkTuple8._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._2@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._2@tok
Typ_fun_873))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a1))
  
:pattern ((Prims.MkTuple8._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__2 @x8))
  
:pattern ((Prims.MkTuple8._2 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._2>

; encoding sigelt Prims.MkTuple8._3

; <Start encoding Prims.MkTuple8._3>
(declare-fun Prims.MkTuple8._3 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'c)
(declare-fun Typ_fun_878 () Type)
;;;;;;;;;;;;;;;;Typ_fun_878 kinding
(assert (HasKind Typ_fun_878
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_878)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_878)))))
;;;;;;;;;;;;;;;;Typ_fun_878 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_878)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_878)))))
(declare-fun Prims.MkTuple8._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 881
(Term_constr_id Prims.MkTuple8._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._3@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._3@tok
Typ_fun_878))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a2))
  
:pattern ((Prims.MkTuple8._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__3 @x8))
  
:pattern ((Prims.MkTuple8._3 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._3>

; encoding sigelt Prims.MkTuple8._4

; <Start encoding Prims.MkTuple8._4>
(declare-fun Prims.MkTuple8._4 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'd)
(declare-fun Typ_fun_883 () Type)
;;;;;;;;;;;;;;;;Typ_fun_883 kinding
(assert (HasKind Typ_fun_883
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_883)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_883)))))
;;;;;;;;;;;;;;;;Typ_fun_883 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_883)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a5))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_883)))))
(declare-fun Prims.MkTuple8._4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 886
(Term_constr_id Prims.MkTuple8._4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._4@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._4@tok
Typ_fun_883))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a3))
  
:pattern ((Prims.MkTuple8._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__4 @x8))
  
:pattern ((Prims.MkTuple8._4 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._4>

; encoding sigelt Prims.MkTuple8._5

; <Start encoding Prims.MkTuple8._5>
(declare-fun Prims.MkTuple8._5 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'e)
(declare-fun Typ_fun_888 () Type)
;;;;;;;;;;;;;;;;Typ_fun_888 kinding
(assert (HasKind Typ_fun_888
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_888)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_888)))))
;;;;;;;;;;;;;;;;Typ_fun_888 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_888)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a6))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_888)))))
(declare-fun Prims.MkTuple8._5@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 891
(Term_constr_id Prims.MkTuple8._5@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._5@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._5@tok
Typ_fun_888))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a4))
  
:pattern ((Prims.MkTuple8._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__5 @x8))
  
:pattern ((Prims.MkTuple8._5 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._5>

; encoding sigelt Prims.MkTuple8._6

; <Start encoding Prims.MkTuple8._6>
(declare-fun Prims.MkTuple8._6 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'f)
(declare-fun Typ_fun_893 () Type)
;;;;;;;;;;;;;;;;Typ_fun_893 kinding
(assert (HasKind Typ_fun_893
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_893)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_893)))))
;;;;;;;;;;;;;;;;Typ_fun_893 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_893)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a7))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_893)))))
(declare-fun Prims.MkTuple8._6@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 896
(Term_constr_id Prims.MkTuple8._6@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._6@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._6@tok
Typ_fun_893))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a5))
  
:pattern ((Prims.MkTuple8._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__6 @x8))
  
:pattern ((Prims.MkTuple8._6 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._6>

; encoding sigelt Prims.MkTuple8._7

; <Start encoding Prims.MkTuple8._7>
(declare-fun Prims.MkTuple8._7 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'g)
(declare-fun Typ_fun_898 () Type)
;;;;;;;;;;;;;;;;Typ_fun_898 kinding
(assert (HasKind Typ_fun_898
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_898)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_898)))))
;;;;;;;;;;;;;;;;Typ_fun_898 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_898)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_898)))))
(declare-fun Prims.MkTuple8._7@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 901
(Term_constr_id Prims.MkTuple8._7@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._7@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._7@tok
Typ_fun_898))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a6))
  
:pattern ((Prims.MkTuple8._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__7 @x8))
  
:pattern ((Prims.MkTuple8._7 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._7>

; encoding sigelt Prims.MkTuple8._8

; <Start encoding Prims.MkTuple8._8>
(declare-fun Prims.MkTuple8._8 (Type Type Type Type Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(Tuple8 'a 'b 'c 'd 'e 'f 'g 'h) -> Tot 'h)
(declare-fun Typ_fun_903 () Type)
;;;;;;;;;;;;;;;;Typ_fun_903 kinding
(assert (HasKind Typ_fun_903
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_903)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_903)))))
;;;;;;;;;;;;;;;;Typ_fun_903 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_903)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@a8 Type) (@a9 Type) (@x10 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasKind @a8
Kind_type)
(HasKind @a9
Kind_type)
(HasType @x10
(Prims.Tuple8 @a2
@a3
@a4
@a5
@a6
@a7
@a8
@a9)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)
@a9))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@a8)
@a9)
@x10)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_903)))))
(declare-fun Prims.MkTuple8._8@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 906
(Term_constr_id Prims.MkTuple8._8@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)
(Prims.MkTuple8._8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkTuple8._8@tok
@a0)
@a1)
@a2)
@a3)
@a4)
@a5)
@a6)
@a7)
@x8)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkTuple8._8@tok
Typ_fun_903))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasKind @a2
Kind_type)
(HasKind @a3
Kind_type)
(HasKind @a4
Kind_type)
(HasKind @a5
Kind_type)
(HasKind @a6
Kind_type)
(HasKind @a7
Kind_type)
(HasType @x8
(Prims.Tuple8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7)))
(HasType (Prims.MkTuple8._8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
@a7))
  
:pattern ((Prims.MkTuple8._8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@a6 Type) (@a7 Type) (@x8 Term))
 (! (= (Prims.MkTuple8._8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)
(Prims.MkTuple8__8 @x8))
  
:pattern ((Prims.MkTuple8._8 @a0
@a1
@a2
@a3
@a4
@a5
@a6
@a7
@x8)))))

; </end encoding Prims.MkTuple8._8>

; encoding sigelt Prims.DTuple2, Prims.MkDTuple2

; <Start encoding >

; <Start encoding Prims.DTuple2>

; <start constructor Prims.DTuple2>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.DTuple2 (Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type))
 (= 918
(Type_constr_id (Prims.DTuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple2@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.DTuple2@a0 (Prims.DTuple2 @a0
@a1))
@a0)
  
:pattern ((Prims.DTuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple2@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (Prims.DTuple2@a1 (Prims.DTuple2 @a0
@a1))
@a1)
  
:pattern ((Prims.DTuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.DTuple2 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
918)
(= @a0
(Prims.DTuple2 (Prims.DTuple2@a0 @a0)
(Prims.DTuple2@a1 @a0)))))

; </end constructor Prims.DTuple2>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.DTuple2@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 919
(Type_constr_id Prims.DTuple2@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.DTuple2@tok
@a0)
@a1)
(Prims.DTuple2 @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.DTuple2@tok
@a0)
@a1)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.DTuple2@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x2 Term))
 (! (implies (HasType @x2
@a0)
(HasKind (ApplyTE @a1
@x2)
Kind_type))
  
:pattern ((ApplyTE @a1
@x2)))))
(HasKind (Prims.DTuple2 @a0
@a1)
Kind_type))
  
:pattern ((Prims.DTuple2 @a0
@a1)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.DTuple2 @a2
@a3))
(= (Prims.DTuple2 @a2
@a3)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.DTuple2 @a2
@a3))))))

; </end encoding Prims.DTuple2>

; <Start encoding Prims.MkDTuple2>

; <start constructor Prims.MkDTuple2>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkDTuple2 (Type Type Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (= 925
(Term_constr_id (Prims.MkDTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple2_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkDTuple2_a (Prims.MkDTuple2 @a0
@a1
@x2
@x3))
@a0)
  
:pattern ((Prims.MkDTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple2_b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkDTuple2_b (Prims.MkDTuple2 @a0
@a1
@x2
@x3))
@a1)
  
:pattern ((Prims.MkDTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple2__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkDTuple2__1 (Prims.MkDTuple2 @a0
@a1
@x2
@x3))
@x2)
  
:pattern ((Prims.MkDTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple2__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkDTuple2__2 (Prims.MkDTuple2 @a0
@a1
@x2
@x3))
@x3)
  
:pattern ((Prims.MkDTuple2 @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkDTuple2 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
925)
(= @x0
(Prims.MkDTuple2 (Prims.MkDTuple2_a @x0)
(Prims.MkDTuple2_b @x0)
(Prims.MkDTuple2__1 @x0)
(Prims.MkDTuple2__2 @x0)))))

; </end constructor Prims.MkDTuple2>
;;;;;;;;;;;;;;;;(_1:a -> _2:(b _1) -> Tot (DTuple2 a b))
(declare-fun Typ_fun_927 () Type)
;;;;;;;;;;;;;;;;Typ_fun_927 kinding
(assert (HasKind Typ_fun_927
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_927)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_927)))))
;;;;;;;;;;;;;;;;Typ_fun_927 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_927)
(forall ((@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a2)
(HasKind (ApplyTE @a3
@x6)
Kind_type))
  
:pattern ((ApplyTE @a3
@x6))))
(HasType @x4
@a2)
(HasType @x5
(ApplyTE @a3
@x4)))
(HasType (ApplyEE (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@x5)
(Prims.DTuple2 @a2
@a3)))
  
:pattern ((ApplyEE (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_927)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkDTuple2
(declare-fun Prims.MkDTuple2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 930
(Term_constr_id Prims.MkDTuple2@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkDTuple2@tok
Typ_fun_927))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (ApplyEE (ApplyEE (ApplyET (ApplyET Prims.MkDTuple2@tok
@a0)
@a1)
@x2)
@x3)
(Prims.MkDTuple2 @a0
@a1
@x2
@x3))
  
:pattern ((ApplyEE (ApplyEE (ApplyET (ApplyET Prims.MkDTuple2@tok
@a0)
@a1)
@x2)
@x3)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a1)
(HasKind (ApplyTE @a2
@x5)
Kind_type))
  
:pattern ((ApplyTE @a2
@x5))))
(HasTypeFuel (SFuel @u0)
@x3
@a1)
(HasTypeFuel (SFuel @u0)
@x4
(ApplyTE @a2
@x3)))
(HasTypeFuel @u0
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)
(Prims.DTuple2 @a1
@a2)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)
(Prims.DTuple2 @a1
@a2))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@a5 Type) (@a6 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)
(Prims.DTuple2 @a5
@a6))
(and (= @a2
@a6)
(= @a1
@a5)
(HasKind @a1
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a1)
(HasKind (ApplyTE @a2
@x7)
Kind_type))
  
:pattern ((ApplyTE @a2
@x7))))
(HasTypeFuel @u0
@x3
@a1)
(HasTypeFuel @u0
@x4
(ApplyTE @a2
@x3))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)
(Prims.DTuple2 @a5
@a6))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@a5 Type) (@a6 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)
(Prims.DTuple2 @a5
@a6))
(and (Valid (Precedes @x3
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)))
(Valid (Precedes @x4
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkDTuple2 @a1
@a2
@x3
@x4)
(Prims.DTuple2 @a5
@a6))))))

; </end encoding Prims.MkDTuple2>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.DTuple2 @a2
@a3))
(and (is-Prims.MkDTuple2 @x1)
(= @a2
(Prims.MkDTuple2_a @x1))
(= @a3
(Prims.MkDTuple2_b @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.DTuple2 @a2
@a3))))))

; </end encoding >

; encoding sigelt Prims.is_MkDTuple2

; <Start encoding Prims.is_MkDTuple2>
(declare-fun Prims.is_MkDTuple2 (Type Type Term) Term)
;;;;;;;;;;;;;;;;((DTuple2 a b) -> Tot bool)
(declare-fun Typ_fun_932 () Type)
;;;;;;;;;;;;;;;;Typ_fun_932 kinding
(assert (HasKind Typ_fun_932
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_932)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_932)))))
;;;;;;;;;;;;;;;;Typ_fun_932 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_932)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a2)
(HasKind (ApplyTE @a3
@x5)
Kind_type))
  
:pattern ((ApplyTE @a3
@x5))))
(HasType @x4
(Prims.DTuple2 @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_932)))))
(declare-fun Prims.is_MkDTuple2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 935
(Term_constr_id Prims.is_MkDTuple2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.is_MkDTuple2@tok
@a0)
@a1)
@x2)
(Prims.is_MkDTuple2 @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.is_MkDTuple2@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkDTuple2@tok
Typ_fun_932))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a1
@x3)
Kind_type))
  
:pattern ((ApplyTE @a1
@x3))))
(HasType @x2
(Prims.DTuple2 @a0
@a1)))
(HasType (Prims.is_MkDTuple2 @a0
@a1
@x2)
Prims.bool))
  
:pattern ((Prims.is_MkDTuple2 @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.is_MkDTuple2 @a0
@a1
@x2)
(BoxBool (is-Prims.MkDTuple2 @x2)))
  
:pattern ((Prims.is_MkDTuple2 @a0
@a1
@x2)))))

; </end encoding Prims.is_MkDTuple2>

; encoding sigelt Prims.MkDTuple2.a

; <Start encoding Prims.MkDTuple2.a>
(declare-fun Prims.MkDTuple2.a (Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple2.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 937
(Type_constr_id Prims.MkDTuple2.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.MkDTuple2.a@tok
@a0)
@a1)
@x2)
(Prims.MkDTuple2.a @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.MkDTuple2.a@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple2.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a1
@x3)
Kind_type))
  
:pattern ((ApplyTE @a1
@x3))))
(HasType @x2
(Prims.DTuple2 @a0
@a1)))
(HasKind (Prims.MkDTuple2.a @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.MkDTuple2.a @a0
@a1
@x2)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkDTuple2.a @a0
@a1
@x2)
(Prims.MkDTuple2_a @x2))
  
:pattern ((Prims.MkDTuple2.a @a0
@a1
@x2)))))

; </end encoding Prims.MkDTuple2.a>

; encoding sigelt Prims.MkDTuple2.b

; <Start encoding Prims.MkDTuple2.b>
(declare-fun Prims.MkDTuple2.b (Type Type Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple2.b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 940
(Type_constr_id Prims.MkDTuple2.b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTT (ApplyTT Prims.MkDTuple2.b@tok
@a0)
@a1)
@x2)
@x3)
(Prims.MkDTuple2.b @a0
@a1
@x2
@x3))
  
:pattern ((ApplyTE (ApplyTE (ApplyTT (ApplyTT Prims.MkDTuple2.b@tok
@a0)
@a1)
@x2)
@x3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple2.b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(HasType @x2
(Prims.DTuple2 @a0
@a1))
(HasType @x3
(Prims.MkDTuple2.a @a0
@a1
@x2)))
(HasKind (Prims.MkDTuple2.b @a0
@a1
@x2
@x3)
Kind_type))
  
:pattern ((Prims.MkDTuple2.b @a0
@a1
@x2
@x3)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term) (@x3 Term))
 (! (= (Prims.MkDTuple2.b @a0
@a1
@x2
@x3)
(ApplyTE (Prims.MkDTuple2_b @x2)
@x3))
  
:pattern ((Prims.MkDTuple2.b @a0
@a1
@x2
@x3)))))

; </end encoding Prims.MkDTuple2.b>

; encoding sigelt Prims.MkDTuple2._1

; <Start encoding Prims.MkDTuple2._1>
(declare-fun Prims.MkDTuple2._1 (Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple2 a b) -> Tot (MkDTuple2.a projectee))
(declare-fun Typ_fun_943 () Type)
;;;;;;;;;;;;;;;;Typ_fun_943 kinding
(assert (HasKind Typ_fun_943
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_943)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_943)))))
;;;;;;;;;;;;;;;;Typ_fun_943 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_943)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a2)
(HasKind (ApplyTE @a3
@x5)
Kind_type))
  
:pattern ((ApplyTE @a3
@x5))))
(HasType @x4
(Prims.DTuple2 @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
(Prims.MkDTuple2.a @a2
@a3
@x4)))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_943)))))
(declare-fun Prims.MkDTuple2._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 946
(Term_constr_id Prims.MkDTuple2._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.MkDTuple2._1@tok
@a0)
@a1)
@x2)
(Prims.MkDTuple2._1 @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.MkDTuple2._1@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple2._1@tok
Typ_fun_943))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a1
@x3)
Kind_type))
  
:pattern ((ApplyTE @a1
@x3))))
(HasType @x2
(Prims.DTuple2 @a0
@a1)))
(HasType (Prims.MkDTuple2._1 @a0
@a1
@x2)
(Prims.MkDTuple2.a @a0
@a1
@x2)))
  
:pattern ((Prims.MkDTuple2._1 @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkDTuple2._1 @a0
@a1
@x2)
(Prims.MkDTuple2__1 @x2))
  
:pattern ((Prims.MkDTuple2._1 @a0
@a1
@x2)))))

; </end encoding Prims.MkDTuple2._1>

; encoding sigelt Prims.MkDTuple2._2

; <Start encoding Prims.MkDTuple2._2>
(declare-fun Prims.MkDTuple2._2 (Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple2 a b) -> Tot (MkDTuple2.b projectee (MkDTuple2._1 projectee)))
(declare-fun Typ_fun_951 () Type)
;;;;;;;;;;;;;;;;Typ_fun_951 kinding
(assert (HasKind Typ_fun_951
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_951)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_951)))))
;;;;;;;;;;;;;;;;Typ_fun_951 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_951)
(forall ((@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a2)
(HasKind (ApplyTE @a3
@x5)
Kind_type))
  
:pattern ((ApplyTE @a3
@x5))))
(HasType @x4
(Prims.DTuple2 @a2
@a3)))
(HasType (ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)
(Prims.MkDTuple2.b @a2
@a3
@x4
(Prims.MkDTuple2._1 @a2
@a3
@x4))))
  
:pattern ((ApplyEE (ApplyET (ApplyET @x1
@a2)
@a3)
@x4)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_951)))))
(declare-fun Prims.MkDTuple2._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 954
(Term_constr_id Prims.MkDTuple2._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.MkDTuple2._2@tok
@a0)
@a1)
@x2)
(Prims.MkDTuple2._2 @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.MkDTuple2._2@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple2._2@tok
Typ_fun_951))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a1
@x3)
Kind_type))
  
:pattern ((ApplyTE @a1
@x3))))
(HasType @x2
(Prims.DTuple2 @a0
@a1)))
(HasType (Prims.MkDTuple2._2 @a0
@a1
@x2)
(Prims.MkDTuple2.b @a0
@a1
@x2
(Prims.MkDTuple2._1 @a0
@a1
@x2))))
  
:pattern ((Prims.MkDTuple2._2 @a0
@a1
@x2)))))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (Prims.MkDTuple2._2 @a0
@a1
@x2)
(Prims.MkDTuple2__2 @x2))
  
:pattern ((Prims.MkDTuple2._2 @a0
@a1
@x2)))))

; </end encoding Prims.MkDTuple2._2>

; encoding sigelt Prims.DTuple3, Prims.MkDTuple3

; <Start encoding >

; <Start encoding Prims.DTuple3>

; <start constructor Prims.DTuple3>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.DTuple3 (Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (= 966
(Type_constr_id (Prims.DTuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple3@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (Prims.DTuple3@a0 (Prims.DTuple3 @a0
@a1
@a2))
@a0)
  
:pattern ((Prims.DTuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple3@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (Prims.DTuple3@a1 (Prims.DTuple3 @a0
@a1
@a2))
@a1)
  
:pattern ((Prims.DTuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple3@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (Prims.DTuple3@a2 (Prims.DTuple3 @a0
@a1
@a2))
@a2)
  
:pattern ((Prims.DTuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.DTuple3 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
966)
(= @a0
(Prims.DTuple3 (Prims.DTuple3@a0 @a0)
(Prims.DTuple3@a1 @a0)
(Prims.DTuple3@a2 @a0)))))

; </end constructor Prims.DTuple3>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.DTuple3@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 967
(Type_constr_id Prims.DTuple3@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT Prims.DTuple3@tok
@a0)
@a1)
@a2)
(Prims.DTuple3 @a0
@a1
@a2))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT Prims.DTuple3@tok
@a0)
@a1)
@a2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.DTuple3@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a1
@x3)
Kind_type))
  
:pattern ((ApplyTE @a1
@x3))))
(forall ((@x3 Term) (@x4 Term))
 (! (implies (and (HasType @x3
@a0)
(HasType @x4
(ApplyTE @a1
@x3)))
(HasKind (ApplyTE (ApplyTE @a2
@x3)
@x4)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x3)
@x4)))))
(HasKind (Prims.DTuple3 @a0
@a1
@a2)
Kind_type))
  
:pattern ((Prims.DTuple3 @a0
@a1
@a2)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.DTuple3 @a2
@a3
@a4))
(= (Prims.DTuple3 @a2
@a3
@a4)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.DTuple3 @a2
@a3
@a4))))))

; </end encoding Prims.DTuple3>

; <Start encoding Prims.MkDTuple3>

; <start constructor Prims.MkDTuple3>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkDTuple3 (Type Type Type Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (= 973
(Term_constr_id (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple3_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3_a (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@a0)
  
:pattern ((Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple3_b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3_b (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@a1)
  
:pattern ((Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple3_c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3_c (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@a2)
  
:pattern ((Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple3__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3__1 (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@x3)
  
:pattern ((Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple3__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3__2 (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@x4)
  
:pattern ((Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple3__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3__3 (Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
@x5)
  
:pattern ((Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkDTuple3 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
973)
(= @x0
(Prims.MkDTuple3 (Prims.MkDTuple3_a @x0)
(Prims.MkDTuple3_b @x0)
(Prims.MkDTuple3_c @x0)
(Prims.MkDTuple3__1 @x0)
(Prims.MkDTuple3__2 @x0)
(Prims.MkDTuple3__3 @x0)))))

; </end constructor Prims.MkDTuple3>
;;;;;;;;;;;;;;;;(_1:a -> _2:(b _1) -> _3:(c _1 _2) -> Tot (DTuple3 a b c))
(declare-fun Typ_fun_975 () Type)
;;;;;;;;;;;;;;;;Typ_fun_975 kinding
(assert (HasKind Typ_fun_975
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_975)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_975)))))
;;;;;;;;;;;;;;;;Typ_fun_975 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_975)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x8 Term))
 (! (implies (HasType @x8
@a2)
(HasKind (ApplyTE @a3
@x8)
Kind_type))
  
:pattern ((ApplyTE @a3
@x8))))
(forall ((@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x8
@a2)
(HasType @x9
(ApplyTE @a3
@x8)))
(HasKind (ApplyTE (ApplyTE @a4
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x8)
@x9))))
(HasType @x5
@a2)
(HasType @x6
(ApplyTE @a3
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a4
@x5)
@x6)))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@x6)
@x7)
(Prims.DTuple3 @a2
@a3
@a4)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
@x6)
@x7)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_975)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkDTuple3
(declare-fun Prims.MkDTuple3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 978
(Term_constr_id Prims.MkDTuple3@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkDTuple3@tok
Typ_fun_975))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3@tok
@a0)
@a1)
@a2)
@x3)
@x4)
@x5)
(Prims.MkDTuple3 @a0
@a1
@a2
@x3
@x4
@x5))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3@tok
@a0)
@a1)
@a2)
@x3)
@x4)
@x5)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a1)
(HasKind (ApplyTE @a2
@x7)
Kind_type))
  
:pattern ((ApplyTE @a2
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a1)
(HasType @x8
(ApplyTE @a2
@x7)))
(HasKind (ApplyTE (ApplyTE @a3
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a3
@x7)
@x8))))
(HasTypeFuel (SFuel @u0)
@x4
@a1)
(HasTypeFuel (SFuel @u0)
@x5
(ApplyTE @a2
@x4))
(HasTypeFuel (SFuel @u0)
@x6
(ApplyTE (ApplyTE @a3
@x4)
@x5)))
(HasTypeFuel @u0
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.DTuple3 @a1
@a2
@a3)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.DTuple3 @a1
@a2
@a3))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@a7 Type) (@a8 Type) (@a9 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.DTuple3 @a7
@a8
@a9))
(and (= @a3
@a9)
(= @a2
@a8)
(= @a1
@a7)
(HasKind @a1
Kind_type)
(forall ((@x10 Term))
 (! (implies (HasType @x10
@a1)
(HasKind (ApplyTE @a2
@x10)
Kind_type))
  
:pattern ((ApplyTE @a2
@x10))))
(forall ((@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x10
@a1)
(HasType @x11
(ApplyTE @a2
@x10)))
(HasKind (ApplyTE (ApplyTE @a3
@x10)
@x11)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a3
@x10)
@x11))))
(HasTypeFuel @u0
@x4
@a1)
(HasTypeFuel @u0
@x5
(ApplyTE @a2
@x4))
(HasTypeFuel @u0
@x6
(ApplyTE (ApplyTE @a3
@x4)
@x5))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.DTuple3 @a7
@a8
@a9))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@a7 Type) (@a8 Type) (@a9 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.DTuple3 @a7
@a8
@a9))
(and (Valid (Precedes @x4
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)))
(Valid (Precedes @x5
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)))
(Valid (Precedes @x6
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkDTuple3 @a1
@a2
@a3
@x4
@x5
@x6)
(Prims.DTuple3 @a7
@a8
@a9))))))

; </end encoding Prims.MkDTuple3>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.DTuple3 @a2
@a3
@a4))
(and (is-Prims.MkDTuple3 @x1)
(= @a2
(Prims.MkDTuple3_a @x1))
(= @a3
(Prims.MkDTuple3_b @x1))
(= @a4
(Prims.MkDTuple3_c @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.DTuple3 @a2
@a3
@a4))))))

; </end encoding >

; encoding sigelt Prims.is_MkDTuple3

; <Start encoding Prims.is_MkDTuple3>
(declare-fun Prims.is_MkDTuple3 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((DTuple3 a b c) -> Tot bool)
(declare-fun Typ_fun_980 () Type)
;;;;;;;;;;;;;;;;Typ_fun_980 kinding
(assert (HasKind Typ_fun_980
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_980)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_980)))))
;;;;;;;;;;;;;;;;Typ_fun_980 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_980)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a2)
(HasKind (ApplyTE @a3
@x6)
Kind_type))
  
:pattern ((ApplyTE @a3
@x6))))
(forall ((@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x6
@a2)
(HasType @x7
(ApplyTE @a3
@x6)))
(HasKind (ApplyTE (ApplyTE @a4
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x6)
@x7))))
(HasType @x5
(Prims.DTuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_980)))))
(declare-fun Prims.is_MkDTuple3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 983
(Term_constr_id Prims.is_MkDTuple3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.is_MkDTuple3@tok
@a0)
@a1)
@a2)
@x3)
(Prims.is_MkDTuple3 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.is_MkDTuple3@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkDTuple3@tok
Typ_fun_980))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4)))
(HasKind (ApplyTE (ApplyTE @a2
@x4)
@x5)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x4)
@x5))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2)))
(HasType (Prims.is_MkDTuple3 @a0
@a1
@a2
@x3)
Prims.bool))
  
:pattern ((Prims.is_MkDTuple3 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.is_MkDTuple3 @a0
@a1
@a2
@x3)
(BoxBool (is-Prims.MkDTuple3 @x3)))
  
:pattern ((Prims.is_MkDTuple3 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.is_MkDTuple3>

; encoding sigelt Prims.MkDTuple3.a

; <Start encoding Prims.MkDTuple3.a>
(declare-fun Prims.MkDTuple3.a (Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple3.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 985
(Type_constr_id Prims.MkDTuple3.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple3.a@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkDTuple3.a @a0
@a1
@a2
@x3))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple3.a@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple3.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4)))
(HasKind (ApplyTE (ApplyTE @a2
@x4)
@x5)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x4)
@x5))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2)))
(HasKind (Prims.MkDTuple3.a @a0
@a1
@a2
@x3)
Kind_type))
  
:pattern ((Prims.MkDTuple3.a @a0
@a1
@a2
@x3)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkDTuple3.a @a0
@a1
@a2
@x3)
(Prims.MkDTuple3_a @x3))
  
:pattern ((Prims.MkDTuple3.a @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkDTuple3.a>

; encoding sigelt Prims.MkDTuple3.b

; <Start encoding Prims.MkDTuple3.b>
(declare-fun Prims.MkDTuple3.b (Type Type Type Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple3.b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 988
(Type_constr_id Prims.MkDTuple3.b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple3.b@tok
@a0)
@a1)
@a2)
@x3)
@x4)
(Prims.MkDTuple3.b @a0
@a1
@a2
@x3
@x4))
  
:pattern ((ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple3.b@tok
@a0)
@a1)
@a2)
@x3)
@x4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple3.b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2))
(HasType @x4
(Prims.MkDTuple3.a @a0
@a1
@a2
@x3)))
(HasKind (Prims.MkDTuple3.b @a0
@a1
@a2
@x3
@x4)
Kind_type))
  
:pattern ((Prims.MkDTuple3.b @a0
@a1
@a2
@x3
@x4)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term))
 (! (= (Prims.MkDTuple3.b @a0
@a1
@a2
@x3
@x4)
(ApplyTE (Prims.MkDTuple3_b @x3)
@x4))
  
:pattern ((Prims.MkDTuple3.b @a0
@a1
@a2
@x3
@x4)))))

; </end encoding Prims.MkDTuple3.b>

; encoding sigelt Prims.MkDTuple3.c

; <Start encoding Prims.MkDTuple3.c>
(declare-fun Prims.MkDTuple3.c (Type Type Type Term Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple3.c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 993
(Type_constr_id Prims.MkDTuple3.c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple3.c@tok
@a0)
@a1)
@a2)
@x3)
@x4)
@x5)
(Prims.MkDTuple3.c @a0
@a1
@a2
@x3
@x4
@x5))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple3.c@tok
@a0)
@a1)
@a2)
@x3)
@x4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple3.c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a0)
(HasKind (ApplyTE @a1
@x6)
Kind_type))
  
:pattern ((ApplyTE @a1
@x6))))
(forall ((@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x6
@a0)
(HasType @x7
(ApplyTE @a1
@x6)))
(HasKind (ApplyTE (ApplyTE @a2
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x6)
@x7))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2))
(HasType @x4
(Prims.MkDTuple3.a @a0
@a1
@a2
@x3))
(HasType @x5
(Prims.MkDTuple3.b @a0
@a1
@a2
@x3
@x4)))
(HasKind (Prims.MkDTuple3.c @a0
@a1
@a2
@x3
@x4
@x5)
Kind_type))
  
:pattern ((Prims.MkDTuple3.c @a0
@a1
@a2
@x3
@x4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple3.c @a0
@a1
@a2
@x3
@x4
@x5)
(ApplyTE (ApplyTE (Prims.MkDTuple3_c @x3)
@x4)
@x5))
  
:pattern ((Prims.MkDTuple3.c @a0
@a1
@a2
@x3
@x4
@x5)))))

; </end encoding Prims.MkDTuple3.c>

; encoding sigelt Prims.MkDTuple3._1

; <Start encoding Prims.MkDTuple3._1>
(declare-fun Prims.MkDTuple3._1 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple3 a b c) -> Tot (MkDTuple3.a projectee))
(declare-fun Typ_fun_996 () Type)
;;;;;;;;;;;;;;;;Typ_fun_996 kinding
(assert (HasKind Typ_fun_996
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_996)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_996)))))
;;;;;;;;;;;;;;;;Typ_fun_996 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_996)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a2)
(HasKind (ApplyTE @a3
@x6)
Kind_type))
  
:pattern ((ApplyTE @a3
@x6))))
(forall ((@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x6
@a2)
(HasType @x7
(ApplyTE @a3
@x6)))
(HasKind (ApplyTE (ApplyTE @a4
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x6)
@x7))))
(HasType @x5
(Prims.DTuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
(Prims.MkDTuple3.a @a2
@a3
@a4
@x5)))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_996)))))
(declare-fun Prims.MkDTuple3._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 999
(Term_constr_id Prims.MkDTuple3._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3._1@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkDTuple3._1 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3._1@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple3._1@tok
Typ_fun_996))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4)))
(HasKind (ApplyTE (ApplyTE @a2
@x4)
@x5)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x4)
@x5))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2)))
(HasType (Prims.MkDTuple3._1 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3.a @a0
@a1
@a2
@x3)))
  
:pattern ((Prims.MkDTuple3._1 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkDTuple3._1 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3__1 @x3))
  
:pattern ((Prims.MkDTuple3._1 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkDTuple3._1>

; encoding sigelt Prims.MkDTuple3._2

; <Start encoding Prims.MkDTuple3._2>
(declare-fun Prims.MkDTuple3._2 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple3 a b c) -> Tot (MkDTuple3.b projectee (MkDTuple3._1 projectee)))
(declare-fun Typ_fun_1004 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1004 kinding
(assert (HasKind Typ_fun_1004
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1004)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1004)))))
;;;;;;;;;;;;;;;;Typ_fun_1004 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1004)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a2)
(HasKind (ApplyTE @a3
@x6)
Kind_type))
  
:pattern ((ApplyTE @a3
@x6))))
(forall ((@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x6
@a2)
(HasType @x7
(ApplyTE @a3
@x6)))
(HasKind (ApplyTE (ApplyTE @a4
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x6)
@x7))))
(HasType @x5
(Prims.DTuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
(Prims.MkDTuple3.b @a2
@a3
@a4
@x5
(Prims.MkDTuple3._1 @a2
@a3
@a4
@x5))))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1004)))))
(declare-fun Prims.MkDTuple3._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1007
(Term_constr_id Prims.MkDTuple3._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3._2@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkDTuple3._2 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3._2@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple3._2@tok
Typ_fun_1004))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4)))
(HasKind (ApplyTE (ApplyTE @a2
@x4)
@x5)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x4)
@x5))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2)))
(HasType (Prims.MkDTuple3._2 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3.b @a0
@a1
@a2
@x3
(Prims.MkDTuple3._1 @a0
@a1
@a2
@x3))))
  
:pattern ((Prims.MkDTuple3._2 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkDTuple3._2 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3__2 @x3))
  
:pattern ((Prims.MkDTuple3._2 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkDTuple3._2>

; encoding sigelt Prims.MkDTuple3._3

; <Start encoding Prims.MkDTuple3._3>
(declare-fun Prims.MkDTuple3._3 (Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple3 a b c) -> Tot (MkDTuple3.c projectee (MkDTuple3._1 projectee) (MkDTuple3._2 projectee)))
(declare-fun Typ_fun_1014 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1014 kinding
(assert (HasKind Typ_fun_1014
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1014)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1014)))))
;;;;;;;;;;;;;;;;Typ_fun_1014 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1014)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a2)
(HasKind (ApplyTE @a3
@x6)
Kind_type))
  
:pattern ((ApplyTE @a3
@x6))))
(forall ((@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x6
@a2)
(HasType @x7
(ApplyTE @a3
@x6)))
(HasKind (ApplyTE (ApplyTE @a4
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x6)
@x7))))
(HasType @x5
(Prims.DTuple3 @a2
@a3
@a4)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)
(Prims.MkDTuple3.c @a2
@a3
@a4
@x5
(Prims.MkDTuple3._1 @a2
@a3
@a4
@x5)
(Prims.MkDTuple3._2 @a2
@a3
@a4
@x5))))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@x5)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1014)))))
(declare-fun Prims.MkDTuple3._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1017
(Term_constr_id Prims.MkDTuple3._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3._3@tok
@a0)
@a1)
@a2)
@x3)
(Prims.MkDTuple3._3 @a0
@a1
@a2
@x3))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET Prims.MkDTuple3._3@tok
@a0)
@a1)
@a2)
@x3)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple3._3@tok
Typ_fun_1014))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4)))
(HasKind (ApplyTE (ApplyTE @a2
@x4)
@x5)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x4)
@x5))))
(HasType @x3
(Prims.DTuple3 @a0
@a1
@a2)))
(HasType (Prims.MkDTuple3._3 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3.c @a0
@a1
@a2
@x3
(Prims.MkDTuple3._1 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3._2 @a0
@a1
@a2
@x3))))
  
:pattern ((Prims.MkDTuple3._3 @a0
@a1
@a2
@x3)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@x3 Term))
 (! (= (Prims.MkDTuple3._3 @a0
@a1
@a2
@x3)
(Prims.MkDTuple3__3 @x3))
  
:pattern ((Prims.MkDTuple3._3 @a0
@a1
@a2
@x3)))))

; </end encoding Prims.MkDTuple3._3>

; encoding sigelt Prims.DTuple4, Prims.MkDTuple4

; <Start encoding >

; <Start encoding Prims.DTuple4>

; <start constructor Prims.DTuple4>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.DTuple4 (Type Type Type Type) Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (= 1029
(Type_constr_id (Prims.DTuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple4@a0 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.DTuple4@a0 (Prims.DTuple4 @a0
@a1
@a2
@a3))
@a0)
  
:pattern ((Prims.DTuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple4@a1 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.DTuple4@a1 (Prims.DTuple4 @a0
@a1
@a2
@a3))
@a1)
  
:pattern ((Prims.DTuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple4@a2 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.DTuple4@a2 (Prims.DTuple4 @a0
@a1
@a2
@a3))
@a2)
  
:pattern ((Prims.DTuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.DTuple4@a3 (Type) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (Prims.DTuple4@a3 (Prims.DTuple4 @a0
@a1
@a2
@a3))
@a3)
  
:pattern ((Prims.DTuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.DTuple4 ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
1029)
(= @a0
(Prims.DTuple4 (Prims.DTuple4@a0 @a0)
(Prims.DTuple4@a1 @a0)
(Prims.DTuple4@a2 @a0)
(Prims.DTuple4@a3 @a0)))))

; </end constructor Prims.DTuple4>
;;;;;;;;;;;;;;;;token
(declare-fun Prims.DTuple4@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1030
(Type_constr_id Prims.DTuple4@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.DTuple4@tok
@a0)
@a1)
@a2)
@a3)
(Prims.DTuple4 @a0
@a1
@a2
@a3))
  
:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.DTuple4@tok
@a0)
@a1)
@a2)
@a3)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.DTuple4@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a1
@x4)
Kind_type))
  
:pattern ((ApplyTE @a1
@x4))))
(forall ((@x4 Term) (@x5 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4)))
(HasKind (ApplyTE (ApplyTE @a2
@x4)
@x5)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x4)
@x5))))
(forall ((@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x4
@a0)
(HasType @x5
(ApplyTE @a1
@x4))
(HasType @x6
(ApplyTE (ApplyTE @a2
@x4)
@x5)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x4)
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x4)
@x5)
@x6)))))
(HasKind (Prims.DTuple4 @a0
@a1
@a2
@a3)
Kind_type))
  
:pattern ((Prims.DTuple4 @a0
@a1
@a2
@a3)))))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel @u1
@x0
(Prims.DTuple4 @a2
@a3
@a4
@a5))
(= (Prims.DTuple4 @a2
@a3
@a4
@a5)
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
(Prims.DTuple4 @a2
@a3
@a4
@a5))))))

; </end encoding Prims.DTuple4>

; <Start encoding Prims.MkDTuple4>

; <start constructor Prims.MkDTuple4>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Prims.MkDTuple4 (Type Type Type Type Term Term Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (= 1036
(Term_constr_id (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4_a (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4_a (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a0)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4_b (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4_b (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a1)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4_c (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4_c (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a2)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4_d (Term) Type)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4_d (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@a3)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4__1 (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x4)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4__2 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4__2 (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x5)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4__3 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4__3 (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x6)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Prims.MkDTuple4__4 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4__4 (Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
@x7)
  
:pattern ((Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Prims.MkDTuple4 ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1036)
(= @x0
(Prims.MkDTuple4 (Prims.MkDTuple4_a @x0)
(Prims.MkDTuple4_b @x0)
(Prims.MkDTuple4_c @x0)
(Prims.MkDTuple4_d @x0)
(Prims.MkDTuple4__1 @x0)
(Prims.MkDTuple4__2 @x0)
(Prims.MkDTuple4__3 @x0)
(Prims.MkDTuple4__4 @x0)))))

; </end constructor Prims.MkDTuple4>
;;;;;;;;;;;;;;;;(_1:a -> _2:(b _1) -> _3:(c _1 _2) -> _4:(d _1 _2 _3) -> Tot (DTuple4 a b c d))
(declare-fun Typ_fun_1038 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1038 kinding
(assert (HasKind Typ_fun_1038
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1038)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1038)))))
;;;;;;;;;;;;;;;;Typ_fun_1038 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1038)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term) (@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x10 Term))
 (! (implies (HasType @x10
@a2)
(HasKind (ApplyTE @a3
@x10)
Kind_type))
  
:pattern ((ApplyTE @a3
@x10))))
(forall ((@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x10
@a2)
(HasType @x11
(ApplyTE @a3
@x10)))
(HasKind (ApplyTE (ApplyTE @a4
@x10)
@x11)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x10)
@x11))))
(forall ((@x10 Term) (@x11 Term) (@x12 Term))
 (! (implies (and (HasType @x10
@a2)
(HasType @x11
(ApplyTE @a3
@x10))
(HasType @x12
(ApplyTE (ApplyTE @a4
@x10)
@x11)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a5
@x10)
@x11)
@x12)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a5
@x10)
@x11)
@x12))))
(HasType @x6
@a2)
(HasType @x7
(ApplyTE @a3
@x6))
(HasType @x8
(ApplyTE (ApplyTE @a4
@x6)
@x7))
(HasType @x9
(ApplyTE (ApplyTE (ApplyTE @a5
@x6)
@x7)
@x8)))
(HasType (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@x7)
@x8)
@x9)
(Prims.DTuple4 @a2
@a3
@a4
@a5)))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
@x7)
@x8)
@x9)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1038)))))
;;;;;;;;;;;;;;;;data constructor proxy: MkDTuple4
(declare-fun Prims.MkDTuple4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1041
(Term_constr_id Prims.MkDTuple4@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Prims.MkDTuple4@tok
Typ_fun_1038))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
@x7)
(Prims.MkDTuple4 @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
  
:pattern ((ApplyEE (ApplyEE (ApplyEE (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
@x7)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasKind @a1
Kind_type)
(forall ((@x9 Term))
 (! (implies (HasType @x9
@a1)
(HasKind (ApplyTE @a2
@x9)
Kind_type))
  
:pattern ((ApplyTE @a2
@x9))))
(forall ((@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x9
@a1)
(HasType @x10
(ApplyTE @a2
@x9)))
(HasKind (ApplyTE (ApplyTE @a3
@x9)
@x10)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a3
@x9)
@x10))))
(forall ((@x9 Term) (@x10 Term) (@x11 Term))
 (! (implies (and (HasType @x9
@a1)
(HasType @x10
(ApplyTE @a2
@x9))
(HasType @x11
(ApplyTE (ApplyTE @a3
@x9)
@x10)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a4
@x9)
@x10)
@x11)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a4
@x9)
@x10)
@x11))))
(HasTypeFuel (SFuel @u0)
@x5
@a1)
(HasTypeFuel (SFuel @u0)
@x6
(ApplyTE @a2
@x5))
(HasTypeFuel (SFuel @u0)
@x7
(ApplyTE (ApplyTE @a3
@x5)
@x6))
(HasTypeFuel (SFuel @u0)
@x8
(ApplyTE (ApplyTE (ApplyTE @a4
@x5)
@x6)
@x7)))
(HasTypeFuel @u0
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.DTuple4 @a1
@a2
@a3
@a4)))
  
:pattern ((HasTypeFuel @u0
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.DTuple4 @a1
@a2
@a3
@a4))))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@a9 Type) (@a10 Type) (@a11 Type) (@a12 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.DTuple4 @a9
@a10
@a11
@a12))
(and (= @a4
@a12)
(= @a3
@a11)
(= @a2
@a10)
(= @a1
@a9)
(HasKind @a1
Kind_type)
(forall ((@x13 Term))
 (! (implies (HasType @x13
@a1)
(HasKind (ApplyTE @a2
@x13)
Kind_type))
  
:pattern ((ApplyTE @a2
@x13))))
(forall ((@x13 Term) (@x14 Term))
 (! (implies (and (HasType @x13
@a1)
(HasType @x14
(ApplyTE @a2
@x13)))
(HasKind (ApplyTE (ApplyTE @a3
@x13)
@x14)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a3
@x13)
@x14))))
(forall ((@x13 Term) (@x14 Term) (@x15 Term))
 (! (implies (and (HasType @x13
@a1)
(HasType @x14
(ApplyTE @a2
@x13))
(HasType @x15
(ApplyTE (ApplyTE @a3
@x13)
@x14)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a4
@x13)
@x14)
@x15)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a4
@x13)
@x14)
@x15))))
(HasTypeFuel @u0
@x5
@a1)
(HasTypeFuel @u0
@x6
(ApplyTE @a2
@x5))
(HasTypeFuel @u0
@x7
(ApplyTE (ApplyTE @a3
@x5)
@x6))
(HasTypeFuel @u0
@x8
(ApplyTE (ApplyTE (ApplyTE @a4
@x5)
@x6)
@x7))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.DTuple4 @a9
@a10
@a11
@a12))))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@a1 Type) (@a2 Type) (@a3 Type) (@a4 Type) (@x5 Term) (@x6 Term) (@x7 Term) (@x8 Term) (@a9 Type) (@a10 Type) (@a11 Type) (@a12 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.DTuple4 @a9
@a10
@a11
@a12))
(and (Valid (Precedes @x5
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))
(Valid (Precedes @x6
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))
(Valid (Precedes @x7
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))
(Valid (Precedes @x8
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Prims.MkDTuple4 @a1
@a2
@a3
@a4
@x5
@x6
@x7
@x8)
(Prims.DTuple4 @a9
@a10
@a11
@a12))))))

; </end encoding Prims.MkDTuple4>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
(Prims.DTuple4 @a2
@a3
@a4
@a5))
(and (is-Prims.MkDTuple4 @x1)
(= @a2
(Prims.MkDTuple4_a @x1))
(= @a3
(Prims.MkDTuple4_b @x1))
(= @a4
(Prims.MkDTuple4_c @x1))
(= @a5
(Prims.MkDTuple4_d @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
(Prims.DTuple4 @a2
@a3
@a4
@a5))))))

; </end encoding >

; encoding sigelt Prims.is_MkDTuple4

; <Start encoding Prims.is_MkDTuple4>
(declare-fun Prims.is_MkDTuple4 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;((DTuple4 a b c d) -> Tot bool)
(declare-fun Typ_fun_1043 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1043 kinding
(assert (HasKind Typ_fun_1043
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1043)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1043)))))
;;;;;;;;;;;;;;;;Typ_fun_1043 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1043)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a2)
(HasKind (ApplyTE @a3
@x7)
Kind_type))
  
:pattern ((ApplyTE @a3
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7)))
(HasKind (ApplyTE (ApplyTE @a4
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x7)
@x8))))
(forall ((@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7))
(HasType @x9
(ApplyTE (ApplyTE @a4
@x7)
@x8)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9))))
(HasType @x6
(Prims.DTuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
Prims.bool))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1043)))))
(declare-fun Prims.is_MkDTuple4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1046
(Term_constr_id Prims.is_MkDTuple4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkDTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.is_MkDTuple4 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.is_MkDTuple4@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.is_MkDTuple4@tok
Typ_fun_1043))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(forall ((@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a2
@x5)
@x6)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.is_MkDTuple4 @a0
@a1
@a2
@a3
@x4)
Prims.bool))
  
:pattern ((Prims.is_MkDTuple4 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.is_MkDTuple4 @a0
@a1
@a2
@a3
@x4)
(BoxBool (is-Prims.MkDTuple4 @x4)))
  
:pattern ((Prims.is_MkDTuple4 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.is_MkDTuple4>

; encoding sigelt Prims.MkDTuple4.a

; <Start encoding Prims.MkDTuple4.a>
(declare-fun Prims.MkDTuple4.a (Type Type Type Type Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple4.a@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1048
(Type_constr_id Prims.MkDTuple4.a@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.a@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.a@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple4.a@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(forall ((@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a2
@x5)
@x6)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3)))
(HasKind (Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4)
Kind_type))
  
:pattern ((Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4_a @x4))
  
:pattern ((Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkDTuple4.a>

; encoding sigelt Prims.MkDTuple4.b

; <Start encoding Prims.MkDTuple4.b>
(declare-fun Prims.MkDTuple4.b (Type Type Type Type Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple4.b@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1051
(Type_constr_id Prims.MkDTuple4.b@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.b@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
(Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5))
  
:pattern ((ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.b@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple4.b@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x6 Term))
 (! (implies (HasType @x6
@a0)
(HasKind (ApplyTE @a1
@x6)
Kind_type))
  
:pattern ((ApplyTE @a1
@x6))))
(forall ((@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x6
@a0)
(HasType @x7
(ApplyTE @a1
@x6)))
(HasKind (ApplyTE (ApplyTE @a2
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x6)
@x7))))
(forall ((@x6 Term) (@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x6
@a0)
(HasType @x7
(ApplyTE @a1
@x6))
(HasType @x8
(ApplyTE (ApplyTE @a2
@x6)
@x7)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x6)
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x6)
@x7)
@x8))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3))
(HasType @x5
(Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4)))
(HasKind (Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5)
Kind_type))
  
:pattern ((Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term))
 (! (= (Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5)
(ApplyTE (Prims.MkDTuple4_b @x4)
@x5))
  
:pattern ((Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5)))))

; </end encoding Prims.MkDTuple4.b>

; encoding sigelt Prims.MkDTuple4.c

; <Start encoding Prims.MkDTuple4.c>
(declare-fun Prims.MkDTuple4.c (Type Type Type Type Term Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple4.c@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1056
(Type_constr_id Prims.MkDTuple4.c@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.c@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
(Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
@x5
@x6))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.c@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple4.c@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a0)
(HasKind (ApplyTE @a1
@x7)
Kind_type))
  
:pattern ((ApplyTE @a1
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a0)
(HasType @x8
(ApplyTE @a1
@x7)))
(HasKind (ApplyTE (ApplyTE @a2
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x7)
@x8))))
(forall ((@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x7
@a0)
(HasType @x8
(ApplyTE @a1
@x7))
(HasType @x9
(ApplyTE (ApplyTE @a2
@x7)
@x8)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x7)
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x7)
@x8)
@x9))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3))
(HasType @x5
(Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4))
(HasType @x6
(Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5)))
(HasKind (Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
@x5
@x6)
Kind_type))
  
:pattern ((Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
@x5
@x6)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term))
 (! (= (Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
@x5
@x6)
(ApplyTE (ApplyTE (Prims.MkDTuple4_c @x4)
@x5)
@x6))
  
:pattern ((Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
@x5
@x6)))))

; </end encoding Prims.MkDTuple4.c>

; encoding sigelt Prims.MkDTuple4.d

; <Start encoding Prims.MkDTuple4.d>
(declare-fun Prims.MkDTuple4.d (Type Type Type Type Term Term Term Term) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.MkDTuple4.d@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1064
(Type_constr_id Prims.MkDTuple4.d@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (ApplyTE (ApplyTE (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.d@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
@x7)
(Prims.MkDTuple4.d @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE (ApplyTE (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.MkDTuple4.d@tok
@a0)
@a1)
@a2)
@a3)
@x4)
@x5)
@x6)
@x7)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.MkDTuple4.d@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x8 Term))
 (! (implies (HasType @x8
@a0)
(HasKind (ApplyTE @a1
@x8)
Kind_type))
  
:pattern ((ApplyTE @a1
@x8))))
(forall ((@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x8
@a0)
(HasType @x9
(ApplyTE @a1
@x8)))
(HasKind (ApplyTE (ApplyTE @a2
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x8)
@x9))))
(forall ((@x8 Term) (@x9 Term) (@x10 Term))
 (! (implies (and (HasType @x8
@a0)
(HasType @x9
(ApplyTE @a1
@x8))
(HasType @x10
(ApplyTE (ApplyTE @a2
@x8)
@x9)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x8)
@x9)
@x10)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x8)
@x9)
@x10))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3))
(HasType @x5
(Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4))
(HasType @x6
(Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
@x5))
(HasType @x7
(Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
@x5
@x6)))
(HasKind (Prims.MkDTuple4.d @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)
Kind_type))
  
:pattern ((Prims.MkDTuple4.d @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))
;;;;;;;;;;;;;;;;projector axiom
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term) (@x5 Term) (@x6 Term) (@x7 Term))
 (! (= (Prims.MkDTuple4.d @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)
(ApplyTE (ApplyTE (ApplyTE (Prims.MkDTuple4_d @x4)
@x5)
@x6)
@x7))
  
:pattern ((Prims.MkDTuple4.d @a0
@a1
@a2
@a3
@x4
@x5
@x6
@x7)))))

; </end encoding Prims.MkDTuple4.d>

; encoding sigelt Prims.MkDTuple4._1

; <Start encoding Prims.MkDTuple4._1>
(declare-fun Prims.MkDTuple4._1 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple4 a b c d) -> Tot (MkDTuple4.a projectee))
(declare-fun Typ_fun_1067 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1067 kinding
(assert (HasKind Typ_fun_1067
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1067)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1067)))))
;;;;;;;;;;;;;;;;Typ_fun_1067 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1067)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a2)
(HasKind (ApplyTE @a3
@x7)
Kind_type))
  
:pattern ((ApplyTE @a3
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7)))
(HasKind (ApplyTE (ApplyTE @a4
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x7)
@x8))))
(forall ((@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7))
(HasType @x9
(ApplyTE (ApplyTE @a4
@x7)
@x8)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9))))
(HasType @x6
(Prims.DTuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkDTuple4.a @a2
@a3
@a4
@a5
@x6)))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1067)))))
(declare-fun Prims.MkDTuple4._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1070
(Term_constr_id Prims.MkDTuple4._1@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._1@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._1@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple4._1@tok
Typ_fun_1067))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(forall ((@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a2
@x5)
@x6)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4.a @a0
@a1
@a2
@a3
@x4)))
  
:pattern ((Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4__1 @x4))
  
:pattern ((Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkDTuple4._1>

; encoding sigelt Prims.MkDTuple4._2

; <Start encoding Prims.MkDTuple4._2>
(declare-fun Prims.MkDTuple4._2 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple4 a b c d) -> Tot (MkDTuple4.b projectee (MkDTuple4._1 projectee)))
(declare-fun Typ_fun_1075 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1075 kinding
(assert (HasKind Typ_fun_1075
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1075)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1075)))))
;;;;;;;;;;;;;;;;Typ_fun_1075 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1075)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a2)
(HasKind (ApplyTE @a3
@x7)
Kind_type))
  
:pattern ((ApplyTE @a3
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7)))
(HasKind (ApplyTE (ApplyTE @a4
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x7)
@x8))))
(forall ((@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7))
(HasType @x9
(ApplyTE (ApplyTE @a4
@x7)
@x8)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9))))
(HasType @x6
(Prims.DTuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkDTuple4.b @a2
@a3
@a4
@a5
@x6
(Prims.MkDTuple4._1 @a2
@a3
@a4
@a5
@x6))))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1075)))))
(declare-fun Prims.MkDTuple4._2@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1078
(Term_constr_id Prims.MkDTuple4._2@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._2@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._2@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple4._2@tok
Typ_fun_1075))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(forall ((@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a2
@x5)
@x6)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4.b @a0
@a1
@a2
@a3
@x4
(Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4))))
  
:pattern ((Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4__2 @x4))
  
:pattern ((Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkDTuple4._2>

; encoding sigelt Prims.MkDTuple4._3

; <Start encoding Prims.MkDTuple4._3>
(declare-fun Prims.MkDTuple4._3 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple4 a b c d) -> Tot (MkDTuple4.c projectee (MkDTuple4._1 projectee) (MkDTuple4._2 projectee)))
(declare-fun Typ_fun_1085 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1085 kinding
(assert (HasKind Typ_fun_1085
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1085)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1085)))))
;;;;;;;;;;;;;;;;Typ_fun_1085 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1085)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a2)
(HasKind (ApplyTE @a3
@x7)
Kind_type))
  
:pattern ((ApplyTE @a3
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7)))
(HasKind (ApplyTE (ApplyTE @a4
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x7)
@x8))))
(forall ((@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7))
(HasType @x9
(ApplyTE (ApplyTE @a4
@x7)
@x8)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9))))
(HasType @x6
(Prims.DTuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkDTuple4.c @a2
@a3
@a4
@a5
@x6
(Prims.MkDTuple4._1 @a2
@a3
@a4
@a5
@x6)
(Prims.MkDTuple4._2 @a2
@a3
@a4
@a5
@x6))))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1085)))))
(declare-fun Prims.MkDTuple4._3@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1088
(Term_constr_id Prims.MkDTuple4._3@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._3@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkDTuple4._3 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._3@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple4._3@tok
Typ_fun_1085))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(forall ((@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a2
@x5)
@x6)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkDTuple4._3 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4.c @a0
@a1
@a2
@a3
@x4
(Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4))))
  
:pattern ((Prims.MkDTuple4._3 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkDTuple4._3 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4__3 @x4))
  
:pattern ((Prims.MkDTuple4._3 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkDTuple4._3>

; encoding sigelt Prims.MkDTuple4._4

; <Start encoding Prims.MkDTuple4._4>
(declare-fun Prims.MkDTuple4._4 (Type Type Type Type Term) Term)
;;;;;;;;;;;;;;;;(projectee:(DTuple4 a b c d) -> Tot (MkDTuple4.d projectee (MkDTuple4._1 projectee) (MkDTuple4._2 projectee) (MkDTuple4._3 projectee)))
(declare-fun Typ_fun_1097 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1097 kinding
(assert (HasKind Typ_fun_1097
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1097)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1097)))))
;;;;;;;;;;;;;;;;Typ_fun_1097 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1097)
(forall ((@a2 Type) (@a3 Type) (@a4 Type) (@a5 Type) (@x6 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(forall ((@x7 Term))
 (! (implies (HasType @x7
@a2)
(HasKind (ApplyTE @a3
@x7)
Kind_type))
  
:pattern ((ApplyTE @a3
@x7))))
(forall ((@x7 Term) (@x8 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7)))
(HasKind (ApplyTE (ApplyTE @a4
@x7)
@x8)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a4
@x7)
@x8))))
(forall ((@x7 Term) (@x8 Term) (@x9 Term))
 (! (implies (and (HasType @x7
@a2)
(HasType @x8
(ApplyTE @a3
@x7))
(HasType @x9
(ApplyTE (ApplyTE @a4
@x7)
@x8)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a5
@x7)
@x8)
@x9))))
(HasType @x6
(Prims.DTuple4 @a2
@a3
@a4
@a5)))
(HasType (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)
(Prims.MkDTuple4.d @a2
@a3
@a4
@a5
@x6
(Prims.MkDTuple4._1 @a2
@a3
@a4
@a5
@x6)
(Prims.MkDTuple4._2 @a2
@a3
@a4
@a5
@x6)
(Prims.MkDTuple4._3 @a2
@a3
@a4
@a5
@x6))))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET @x1
@a2)
@a3)
@a4)
@a5)
@x6)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1097)))))
(declare-fun Prims.MkDTuple4._4@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1100
(Term_constr_id Prims.MkDTuple4._4@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._4@tok
@a0)
@a1)
@a2)
@a3)
@x4)
(Prims.MkDTuple4._4 @a0
@a1
@a2
@a3
@x4))
  
:pattern ((ApplyEE (ApplyET (ApplyET (ApplyET (ApplyET Prims.MkDTuple4._4@tok
@a0)
@a1)
@a2)
@a3)
@x4)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.MkDTuple4._4@tok
Typ_fun_1097))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@x5 Term))
 (! (implies (HasType @x5
@a0)
(HasKind (ApplyTE @a1
@x5)
Kind_type))
  
:pattern ((ApplyTE @a1
@x5))))
(forall ((@x5 Term) (@x6 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5)))
(HasKind (ApplyTE (ApplyTE @a2
@x5)
@x6)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE @a2
@x5)
@x6))))
(forall ((@x5 Term) (@x6 Term) (@x7 Term))
 (! (implies (and (HasType @x5
@a0)
(HasType @x6
(ApplyTE @a1
@x5))
(HasType @x7
(ApplyTE (ApplyTE @a2
@x5)
@x6)))
(HasKind (ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7)
Kind_type))
  
:pattern ((ApplyTE (ApplyTE (ApplyTE @a3
@x5)
@x6)
@x7))))
(HasType @x4
(Prims.DTuple4 @a0
@a1
@a2
@a3)))
(HasType (Prims.MkDTuple4._4 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4.d @a0
@a1
@a2
@a3
@x4
(Prims.MkDTuple4._1 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4._2 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4._3 @a0
@a1
@a2
@a3
@x4))))
  
:pattern ((Prims.MkDTuple4._4 @a0
@a1
@a2
@a3
@x4)))))
(assert (forall ((@a0 Type) (@a1 Type) (@a2 Type) (@a3 Type) (@x4 Term))
 (! (= (Prims.MkDTuple4._4 @a0
@a1
@a2
@a3
@x4)
(Prims.MkDTuple4__4 @x4))
  
:pattern ((Prims.MkDTuple4._4 @a0
@a1
@a2
@a3
@x4)))))

; </end encoding Prims.MkDTuple4._4>

; encoding sigelt Prims.as_requires

; <Start encoding Prims.as_requires>
(declare-fun Prims.as_requires (Type Type) Type)
(declare-fun Prims.as_requires@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1101
(Type_constr_id Prims.as_requires@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type))
 (! (= (ApplyTT (ApplyTT Prims.as_requires@tok
@a0)
@a1)
(Prims.as_requires @a0
@a1))
  
:pattern ((ApplyTT (ApplyTT Prims.as_requires@tok
@a0)
@a1)))))
(declare-fun Typ_lam_1102 (Type) Type)
;;;;;;;;;;;;;;;;Typ_lam interpretation
(assert (forall ((@x0 Term) (@a1 Type))
 (! (implies (HasType @x0
@a1)
(= (ApplyTE (Typ_lam_1102 @a1)
@x0)
Prims.True))
  
:pattern ((ApplyTE (Typ_lam_1102 @a1)
@x0)))))
;;;;;;;;;;;;;;;;Typ_lam kinding
(assert (forall ((@a0 Type))
 (! (and (is-Kind_arrow (PreKind (Typ_lam_1102 @a0)))
(forall ((@x1 Term))
 (! (implies (HasType @x1
@a0)
(HasKind (ApplyTE (Typ_lam_1102 @a0)
@x1)
Kind_type))
  
:pattern ((ApplyTE (Typ_lam_1102 @a0)
@x1)))))
  
:pattern ((Typ_lam_1102 @a0)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@a2 Type))
 (! (implies (forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a2
@x3)
Kind_type))
  
:pattern ((ApplyTE @a2
@x3))))
(HasKind (ApplyTT @a2
@a2)
Kind_type))
  
:pattern ((ApplyTT @a2
@a2)))))
(= (Prims.as_requires @a0
@a1)
(ApplyTT @a1
(Typ_lam_1102 @a0))))
  
:pattern ((Prims.as_requires @a0
@a1)))))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (forall ((@a0 Type) (@a1 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@a2 Type))
 (! (implies (forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a2
@x3)
Kind_type))
  
:pattern ((ApplyTE @a2
@x3))))
(HasKind (ApplyTT @a2
@a2)
Kind_type))
  
:pattern ((ApplyTT @a2
@a2)))))
(HasKind (Prims.as_requires @a0
@a1)
Kind_type))
  
:pattern ((Prims.as_requires @a0
@a1)))))

; </end encoding Prims.as_requires>

; encoding sigelt Prims.as_ensures

; <Start encoding Prims.as_ensures>
(declare-fun Prims.as_ensures (Type Type Term) Type)
(declare-fun Prims.as_ensures@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1103
(Type_constr_id Prims.as_ensures@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyTE (ApplyTT (ApplyTT Prims.as_ensures@tok
@a0)
@a1)
@x2)
(Prims.as_ensures @a0
@a1
@x2))
  
:pattern ((ApplyTE (ApplyTT (ApplyTT Prims.as_ensures@tok
@a0)
@a1)
@x2)))))
(declare-fun Typ_lam_1104 (Term Type) Type)
;;;;;;;;;;;;;;;;Typ_lam interpretation
(assert (forall ((@x0 Term) (@x1 Term) (@a2 Type))
 (! (implies (HasType @x0
@a2)
(= (ApplyTE (Typ_lam_1104 @x1
@a2)
@x0)
(Prims.l_not (Prims.b2t (Prims.op_Equality @a2
@x0
@x1)))))
  
:pattern ((ApplyTE (Typ_lam_1104 @x1
@a2)
@x0)))))
;;;;;;;;;;;;;;;;Typ_lam kinding
(assert (forall ((@x0 Term) (@a1 Type))
 (! (and (is-Kind_arrow (PreKind (Typ_lam_1104 @x0
@a1)))
(forall ((@x2 Term))
 (! (implies (HasType @x2
@a1)
(HasKind (ApplyTE (Typ_lam_1104 @x0
@a1)
@x2)
Kind_type))
  
:pattern ((ApplyTE (Typ_lam_1104 @x0
@a1)
@x2)))))
  
:pattern ((Typ_lam_1104 @x0
@a1)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@a3 Type))
 (! (implies (forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a3
@x4)
Kind_type))
  
:pattern ((ApplyTE @a3
@x4))))
(HasKind (ApplyTT @a3
@a3)
Kind_type))
  
:pattern ((ApplyTT @a3
@a3))))
(HasType @x2
@a0))
(= (Valid (Prims.as_ensures @a0
@a1
@x2))
(not (Valid (ApplyTT @a1
(Typ_lam_1104 @x2
@a0))))))
  
:pattern ((Valid (Prims.as_ensures @a0
@a1
@x2))))))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(forall ((@a3 Type))
 (! (implies (forall ((@x4 Term))
 (! (implies (HasType @x4
@a0)
(HasKind (ApplyTE @a3
@x4)
Kind_type))
  
:pattern ((ApplyTE @a3
@x4))))
(HasKind (ApplyTT @a3
@a3)
Kind_type))
  
:pattern ((ApplyTT @a3
@a3))))
(HasType @x2
@a0))
(HasKind (Prims.as_ensures @a0
@a1
@x2)
Kind_type))
  
:pattern ((Prims.as_ensures @a0
@a1
@x2)))))

; </end encoding Prims.as_ensures>

; encoding sigelt Prims.fst

; <Start encoding Prims.fst>
(declare-fun Prims.fst (Type Type Term) Term)
(declare-fun Prims.fst@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1106
(Term_constr_id Prims.fst@tok)))
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (= (ApplyEE (ApplyET (ApplyET Prims.fst@tok
@a0)
@a1)
@x2)
(Prims.fst @a0
@a1
@x2))
  
:pattern ((ApplyEE (ApplyET (ApplyET Prims.fst@tok
@a0)
@a1)
@x2)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.fst@tok
Typ_fun_493))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(HasType (Prims.fst @a0
@a1
@x2)
@a0))
  
:pattern ((Prims.fst @a0
@a1
@x2)))))

; </end encoding Prims.fst>

; encoding sigelt let Prims.fst : ((Tuple2 'a 'b) -> Tot 'a)

; <Start encoding Prims.fst>
;;;;;;;;;;;;;;;;Equation for Prims.fst
(assert (forall ((@a0 Type) (@a1 Type) (@x2 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasKind @a1
Kind_type)
(HasType @x2
(Prims.Tuple2 @a0
@a1)))
(= (Prims.fst @a0
@a1
@x2)
(Prims.MkTuple2._1 @a0
@a1
@x2)))
  
:pattern ((Prims.fst @a0
@a1
@x2)))))

; </end encoding Prims.fst>

; encoding sigelt Prims.Let

; <Start encoding Prims.Let>
(declare-fun Prims.Let (Type Term Type) Type)
(declare-fun Prims.Let@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1107
(Type_constr_id Prims.Let@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term) (@a2 Type))
 (! (= (ApplyTT (ApplyTE (ApplyTT Prims.Let@tok
@a0)
@x1)
@a2)
(Prims.Let @a0
@x1
@a2))
  
:pattern ((ApplyTT (ApplyTE (ApplyTT Prims.Let@tok
@a0)
@x1)
@a2)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (forall ((@a0 Type) (@x1 Term) (@a2 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a2
@x3)
Kind_type))
  
:pattern ((ApplyTE @a2
@x3)))))
(= (Prims.Let @a0
@x1
@a2)
(ApplyTE @a2
@x1)))
  
:pattern ((Prims.Let @a0
@x1
@a2)))))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (forall ((@a0 Type) (@x1 Term) (@a2 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0)
(forall ((@x3 Term))
 (! (implies (HasType @x3
@a0)
(HasKind (ApplyTE @a2
@x3)
Kind_type))
  
:pattern ((ApplyTE @a2
@x3)))))
(HasKind (Prims.Let @a0
@x1
@a2)
Kind_type))
  
:pattern ((Prims.Let @a0
@x1
@a2)))))

; </end encoding Prims.Let>

; encoding sigelt Prims.InductionHyp

; <Start encoding Prims.InductionHyp>
(declare-fun Prims.InductionHyp (Type Term Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.InductionHyp@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1109
(Type_constr_id Prims.InductionHyp@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type) (@x1 Term) (@a2 Type))
 (! (= (ApplyTT (ApplyTE (ApplyTT Prims.InductionHyp@tok
@a0)
@x1)
@a2)
(Prims.InductionHyp @a0
@x1
@a2))
  
:pattern ((ApplyTT (ApplyTE (ApplyTT Prims.InductionHyp@tok
@a0)
@x1)
@a2)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.InductionHyp@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type) (@x1 Term) (@a2 Type))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0)
(HasKind @a2
Kind_type))
(HasKind (Prims.InductionHyp @a0
@x1
@a2)
Kind_type))
  
:pattern ((Prims.InductionHyp @a0
@x1
@a2)))))

; </end encoding Prims.InductionHyp>

; encoding sigelt Prims.by_induction_on

; <Start encoding Prims.by_induction_on>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.by_induction_on (Type Type Term Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.by_induction_on@tok () Term)

; </end encoding Prims.by_induction_on>

; encoding sigelt Prims._assume

; <Start encoding Prims._assume>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims._assume (Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims._assume@tok () Term)

; </end encoding Prims._assume>

; encoding sigelt Prims.admit

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

; </end encoding Prims.admit>

; encoding sigelt Prims.magic

; <Start encoding Prims.magic>
(declare-fun Prims.magic (Type Term) Term)
;;;;;;;;;;;;;;;;(unit -> Tot a)
(declare-fun Typ_fun_1111 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1111 kinding
(assert (HasKind Typ_fun_1111
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1111)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1111)))))
;;;;;;;;;;;;;;;;Typ_fun_1111 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1111)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
Prims.unit))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
@a2))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1111)))))
(declare-fun Prims.magic@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1114
(Term_constr_id Prims.magic@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.magic@tok
@a0)
@x1)
(Prims.magic @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.magic@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.magic@tok
Typ_fun_1111))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
Prims.unit))
(HasType (Prims.magic @a0
@x1)
@a0))
  
:pattern ((Prims.magic @a0
@x1)))))

; </end encoding Prims.magic>

; encoding sigelt Prims.admitP

; <Start encoding Prims.admitP>
(declare-fun Prims.admitP (Type) Term)
(declare-fun Non_total_Typ_fun_1115 () Type)
(assert (HasKind Non_total_Typ_fun_1115
Kind_type))
;;;;;;;;;;;;;;;;pre-typing
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Non_total_Typ_fun_1115)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Non_total_Typ_fun_1115)))))
(declare-fun Prims.admitP@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1117
(Term_constr_id Prims.admitP@tok)))
(assert (forall ((@a0 Type))
 (! (= (ApplyET Prims.admitP@tok
@a0)
(Prims.admitP @a0))
  
:pattern ((ApplyET Prims.admitP@tok
@a0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.admitP@tok
Non_total_Typ_fun_1115))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasType (Prims.admitP @a0)
Prims.unit))
  
:pattern ((Prims.admitP @a0)))))

; </end encoding Prims.admitP>

; encoding sigelt Prims._assert

; <Start encoding Prims._assert>
(declare-fun Prims._assert (Type Term) Term)
(declare-fun Non_total_Typ_fun_1118 () Type)
(assert (HasKind Non_total_Typ_fun_1118
Kind_type))
;;;;;;;;;;;;;;;;pre-typing
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Non_total_Typ_fun_1118)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Non_total_Typ_fun_1118)))))
(declare-fun Prims._assert@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1120
(Term_constr_id Prims._assert@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims._assert@tok
@a0)
@x1)
(Prims._assert @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims._assert@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims._assert@tok
Non_total_Typ_fun_1118))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
Prims.unit))
(HasType (Prims._assert @a0
@x1)
Prims.unit))
  
:pattern ((Prims._assert @a0
@x1)))))

; </end encoding Prims._assert>

; encoding sigelt Prims.cut

; <Start encoding Prims.cut>
(declare-fun Prims.cut (Type) Term)
(declare-fun Non_total_Typ_fun_1121 () Type)
(assert (HasKind Non_total_Typ_fun_1121
Kind_type))
;;;;;;;;;;;;;;;;pre-typing
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Non_total_Typ_fun_1121)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Non_total_Typ_fun_1121)))))
(declare-fun Prims.cut@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1123
(Term_constr_id Prims.cut@tok)))
(assert (forall ((@a0 Type))
 (! (= (ApplyET Prims.cut@tok
@a0)
(Prims.cut @a0))
  
:pattern ((ApplyET Prims.cut@tok
@a0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.cut@tok
Non_total_Typ_fun_1121))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasType (Prims.cut @a0)
Prims.unit))
  
:pattern ((Prims.cut @a0)))))

; </end encoding Prims.cut>

; encoding sigelt Prims.qintro

; <Start encoding Prims.qintro>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.qintro (Type Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.qintro@tok () Term)

; </end encoding Prims.qintro>

; encoding sigelt Prims.failwith

; <Start encoding Prims.failwith>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.failwith (Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.failwith@tok () Term)

; </end encoding Prims.failwith>

; encoding sigelt Prims.raise

; <Start encoding Prims.raise>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.raise (Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.raise@tok () Term)

; </end encoding Prims.raise>

; encoding sigelt Prims.pipe_right

; <Start encoding Prims.pipe_right>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.pipe_right (Type Type Term Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.pipe_right@tok () Term)

; </end encoding Prims.pipe_right>

; encoding sigelt Prims.pipe_left

; <Start encoding Prims.pipe_left>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.pipe_left (Type Type Term Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.pipe_left@tok () Term)

; </end encoding Prims.pipe_left>

; encoding sigelt Prims.ignore

; <Start encoding Prims.ignore>
(declare-fun Prims.ignore (Type Term) Term)
;;;;;;;;;;;;;;;;('a -> Tot unit)
(declare-fun Typ_fun_1131 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1131 kinding
(assert (HasKind Typ_fun_1131
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1131)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1131)))))
;;;;;;;;;;;;;;;;Typ_fun_1131 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1131)
(forall ((@a2 Type) (@x3 Term))
 (! (implies (and (HasKind @a2
Kind_type)
(HasType @x3
@a2))
(HasType (ApplyEE (ApplyET @x1
@a2)
@x3)
Prims.unit))
  
:pattern ((ApplyEE (ApplyET @x1
@a2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1131)))))
(declare-fun Prims.ignore@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1134
(Term_constr_id Prims.ignore@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.ignore@tok
@a0)
@x1)
(Prims.ignore @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.ignore@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.ignore@tok
Typ_fun_1131))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0))
(HasType (Prims.ignore @a0
@x1)
Prims.unit))
  
:pattern ((Prims.ignore @a0
@x1)))))

; </end encoding Prims.ignore>

; encoding sigelt let Prims.ignore : ('a -> Tot unit)

; <Start encoding Prims.ignore>
;;;;;;;;;;;;;;;;Equation for Prims.ignore
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0))
(= (Prims.ignore @a0
@x1)
Term_unit))
  
:pattern ((Prims.ignore @a0
@x1)))))

; </end encoding Prims.ignore>

; encoding sigelt Prims.erase

; <Start encoding Prims.erase>
(declare-fun Prims.erase (Type Term) Term)
(declare-fun Prims.erase@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1136
(Term_constr_id Prims.erase@tok)))
(assert (forall ((@a0 Type) (@x1 Term))
 (! (= (ApplyEE (ApplyET Prims.erase@tok
@a0)
@x1)
(Prims.erase @a0
@x1))
  
:pattern ((ApplyEE (ApplyET Prims.erase@tok
@a0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.erase@tok
Typ_fun_1131))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0))
(HasType (Prims.erase @a0
@x1)
Prims.unit))
  
:pattern ((Prims.erase @a0
@x1)))))

; </end encoding Prims.erase>

; encoding sigelt let Prims.erase : ('a -> Tot unit)

; <Start encoding Prims.erase>
;;;;;;;;;;;;;;;;Equation for Prims.erase
(assert (forall ((@a0 Type) (@x1 Term))
 (! (implies (and (HasKind @a0
Kind_type)
(HasType @x1
@a0))
(= (Prims.erase @a0
@x1)
Term_unit))
  
:pattern ((Prims.erase @a0
@x1)))))

; </end encoding Prims.erase>

; encoding sigelt Prims.exit

; <Start encoding Prims.exit>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.exit (Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.exit@tok () Term)

; </end encoding Prims.exit>

; encoding sigelt Prims.try_with

; <Start encoding Prims.try_with>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Prims.try_with (Type Term Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Prims.try_with@tok () Term)

; </end encoding Prims.try_with>

; encoding sigelt Prims.min

; <Start encoding Prims.min>
(declare-fun Prims.min (Term Term) Term)
;;;;;;;;;;;;;;;;(int -> int -> Tot int)
(declare-fun Typ_fun_1138 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1138 kinding
(assert (HasKind Typ_fun_1138
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1138)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1138)))))
;;;;;;;;;;;;;;;;Typ_fun_1138 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1138)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Prims.int)
(HasType @x3
Prims.int))
(HasType (ApplyEE (ApplyEE @x1
@x2)
@x3)
Prims.int))
  
:pattern ((ApplyEE (ApplyEE @x1
@x2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1138)))))
(declare-fun Prims.min@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1141
(Term_constr_id Prims.min@tok)))
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Prims.min@tok
@x0)
@x1)
(Prims.min @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Prims.min@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.min@tok
Typ_fun_1138))
;;;;;;;;;;;;;;;;free var typing
(assert (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)))))

; </end encoding Prims.min>

; encoding sigelt Prims.max

; <Start encoding Prims.max>
(declare-fun Prims.max (Term Term) Term)
(declare-fun Prims.max@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1143
(Term_constr_id Prims.max@tok)))
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Prims.max@tok
@x0)
@x1)
(Prims.max @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Prims.max@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Prims.max@tok
Typ_fun_1138))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Prims.int)
(HasType @x1
Prims.int))
(HasType (Prims.max @x0
@x1)
Prims.int))
  
:pattern ((Prims.max @x0
@x1)))))

; </end encoding Prims.max>

; encoding sigelt Prims.nat

; <Start encoding Prims.nat>
(declare-fun Prims.nat () Type)
(declare-fun Prims.nat@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.nat@tok
Prims.nat))
(declare-fun Typ_refine_1144 () Type)
(assert (HasKind Typ_refine_1144
Kind_type))
;;;;;;;;;;;;;;;;i:int{(i >= 0)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1144)
(and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1144)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.nat
Typ_refine_1144))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.nat
Kind_type))

; </end encoding Prims.nat>

; encoding sigelt Prims.pos

; <Start encoding Prims.pos>
(declare-fun Prims.pos () Type)
(declare-fun Prims.pos@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.pos@tok
Prims.pos))
(declare-fun Typ_refine_1146 () Type)
(assert (HasKind Typ_refine_1146
Kind_type))
;;;;;;;;;;;;;;;;i:int{(i > 0)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1146)
(and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThan @x1
(BoxInt 0))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1146)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.pos
Typ_refine_1146))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.pos
Kind_type))

; </end encoding Prims.pos>

; encoding sigelt Prims.nonzero

; <Start encoding Prims.nonzero>
(declare-fun Prims.nonzero () Type)
(declare-fun Prims.nonzero@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Prims.nonzero@tok
Prims.nonzero))
(declare-fun Typ_refine_1148 () Type)
(assert (HasKind Typ_refine_1148
Kind_type))
;;;;;;;;;;;;;;;;i:int{(i <> 0)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1148)
(and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_disEquality Prims.int
@x1
(BoxInt 0))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1148)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Prims.nonzero
Typ_refine_1148))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Prims.nonzero
Kind_type))

; </end encoding Prims.nonzero>

; encoding sigelt Prims.op_Modulus

; <Start encoding Prims.op_Modulus>
(declare-fun Prims.op_Modulus (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_Modulus>

; encoding sigelt Prims.op_Division

; <Start encoding Prims.op_Division>
(declare-fun Prims.op_Division (Term Term) Term)
(assert (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)))))

; </end encoding Prims.op_Division>

; encoding sigelt Prims.Boxed

; <Start encoding Prims.Boxed>
(declare-fun Prims.Boxed (Type) Type)
;;;;;;;;;;;;;;;;token
(declare-fun Prims.Boxed@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1151
(Type_constr_id Prims.Boxed@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@a0 Type))
 (! (= (ApplyTT Prims.Boxed@tok
@a0)
(Prims.Boxed @a0))
  
:pattern ((ApplyTT Prims.Boxed@tok
@a0)))))
;;;;;;;;;;;;;;;;kinding
(assert (is-Kind_arrow (PreKind Prims.Boxed@tok)))
;;;;;;;;;;;;;;;;kinding
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasKind (Prims.Boxed @a0)
Kind_type))
  
:pattern ((Prims.Boxed @a0)))))

; </end encoding Prims.Boxed>

; Externals for module Classical

; <Skipped />

; <Start encoding Classical.excluded_middle>
(declare-fun Classical.excluded_middle (Type) Term)
(declare-fun Typ_refine_1166 (Type) Type)
(assert (forall ((@a0 Type))
 (! (HasKind (Typ_refine_1166 @a0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1166 @a0)
Kind_type)))))
;;;;;;;;;;;;;;;;b:bool{((b = true) <==> p)}
(assert (forall ((@u0 Fuel) (@x1 Term) (@a2 Type))
 (! (iff (HasType @x1
(Typ_refine_1166 @a2))
(and (HasType @x1
Prims.bool)
(iff (Valid (Prims.b2t (Prims.op_Equality Prims.bool
@x1
(BoxBool true))))
(Valid @a2))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1166 @a2))))))
;;;;;;;;;;;;;;;;(p:Type -> Tot b:bool{((b = true) <==> p)})
(declare-fun Typ_fun_1168 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1168 kinding
(assert (HasKind Typ_fun_1168
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1168)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1168)))))
;;;;;;;;;;;;;;;;Typ_fun_1168 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1168)
(forall ((@a2 Type))
 (! (implies (HasKind @a2
Kind_type)
(HasType (ApplyET @x1
@a2)
(Typ_refine_1166 @a2)))
  
:pattern ((ApplyET @x1
@a2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1168)))))
(declare-fun Classical.excluded_middle@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1171
(Term_constr_id Classical.excluded_middle@tok)))
(assert (forall ((@a0 Type))
 (! (= (ApplyET Classical.excluded_middle@tok
@a0)
(Classical.excluded_middle @a0))
  
:pattern ((ApplyET Classical.excluded_middle@tok
@a0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Classical.excluded_middle@tok
Typ_fun_1168))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@a0 Type))
 (! (implies (HasKind @a0
Kind_type)
(HasType (Classical.excluded_middle @a0)
(Typ_refine_1166 @a0)))
  
:pattern ((Classical.excluded_middle @a0)))))

; </end encoding Classical.excluded_middle>

; <Start encoding Classical.forall_intro>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Classical.forall_intro (Type Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Classical.forall_intro@tok () Term)

; </end encoding Classical.forall_intro>

; <Start encoding Classical.give_proof>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Classical.give_proof (Type Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Classical.give_proof@tok () Term)

; </end encoding Classical.give_proof>

; End Externals for module Classical
(push)

; Internals for module Test
(push)

; Recursive bindings: Test.exp, Test.EVar, Test.EApp, Test.ELam

; encoding sigelt Test.exp

; <Start encoding Test.exp>

; <start constructor Test.exp>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.exp () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 1172
(Type_constr_id Test.exp)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.exp ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
1172)
(= @a0
Test.exp)))

; </end constructor Test.exp>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Test.exp
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Test.exp)
(= Test.exp
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Test.exp)))))

; </end encoding Test.exp>

; encoding sigelt Test.EVar

; <Start encoding Test.EVar>

; <start constructor Test.EVar>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.EVar (Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term))
 (= 1176
(Term_constr_id (Test.EVar @x0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.EVar__0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term))
 (! (= (Test.EVar__0 (Test.EVar @x0))
@x0)
  
:pattern ((Test.EVar @x0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.EVar ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1176)
(= @x0
(Test.EVar (Test.EVar__0 @x0)))))

; </end constructor Test.EVar>
;;;;;;;;;;;;;;;;(_0:nat -> Tot exp)
(declare-fun Typ_fun_1178 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1178 kinding
(assert (HasKind Typ_fun_1178
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1178)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1178)))))
;;;;;;;;;;;;;;;;Typ_fun_1178 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1178)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Prims.nat@tok)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1178)))))
;;;;;;;;;;;;;;;;data constructor proxy: EVar
(declare-fun Test.EVar@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1181
(Term_constr_id Test.EVar@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Test.EVar@tok
Typ_fun_1178))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.EVar@tok
@x0)
(Test.EVar @x0))
  
:pattern ((ApplyEE Test.EVar@tok
@x0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Prims.nat@tok)
(HasTypeFuel @u0
(Test.EVar @x1)
Test.exp))
  
:pattern ((HasTypeFuel @u0
(Test.EVar @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)
(HasTypeFuel @u0
@x1
Prims.nat@tok))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)
(Valid (Precedes @x1
(Test.EVar @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)))))

; </end encoding Test.EVar>

; encoding sigelt Test.EApp

; <Start encoding Test.EApp>

; <start constructor Test.EApp>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.EApp (Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term) (@x1 Term))
 (= 1183
(Term_constr_id (Test.EApp @x0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.EApp__0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (Test.EApp__0 (Test.EApp @x0
@x1))
@x0)
  
:pattern ((Test.EApp @x0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.EApp__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (Test.EApp__1 (Test.EApp @x0
@x1))
@x1)
  
:pattern ((Test.EApp @x0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.EApp ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1183)
(= @x0
(Test.EApp (Test.EApp__0 @x0)
(Test.EApp__1 @x0)))))

; </end constructor Test.EApp>
;;;;;;;;;;;;;;;;(_0:exp -> _1:exp -> Tot exp)
(declare-fun Typ_fun_1185 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1185 kinding
(assert (HasKind Typ_fun_1185
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1185)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1185)))))
;;;;;;;;;;;;;;;;Typ_fun_1185 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1185)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Test.exp)
(HasType @x3
Test.exp))
(HasType (ApplyEE (ApplyEE @x1
@x2)
@x3)
Test.exp))
  
:pattern ((ApplyEE (ApplyEE @x1
@x2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1185)))))
;;;;;;;;;;;;;;;;data constructor proxy: EApp
(declare-fun Test.EApp@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1188
(Term_constr_id Test.EApp@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Test.EApp@tok
Typ_fun_1185))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Test.EApp@tok
@x0)
@x1)
(Test.EApp @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Test.EApp@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasTypeFuel (SFuel @u0)
@x1
Test.exp)
(HasTypeFuel (SFuel @u0)
@x2
Test.exp))
(HasTypeFuel @u0
(Test.EApp @x1
@x2)
Test.exp))
  
:pattern ((HasTypeFuel @u0
(Test.EApp @x1
@x2)
Test.exp)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)
(and (HasTypeFuel @u0
@x1
Test.exp)
(HasTypeFuel @u0
@x2
Test.exp)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)
(and (Valid (Precedes @x1
(Test.EApp @x1
@x2)))
(Valid (Precedes @x2
(Test.EApp @x1
@x2)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)))))

; </end encoding Test.EApp>

; encoding sigelt Test.ELam

; <Start encoding Test.ELam>

; <start constructor Test.ELam>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.ELam (Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term))
 (= 1190
(Term_constr_id (Test.ELam @x0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.ELam__0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term))
 (! (= (Test.ELam__0 (Test.ELam @x0))
@x0)
  
:pattern ((Test.ELam @x0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.ELam ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1190)
(= @x0
(Test.ELam (Test.ELam__0 @x0)))))

; </end constructor Test.ELam>
;;;;;;;;;;;;;;;;(_0:exp -> Tot exp)
(declare-fun Typ_fun_1192 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1192 kinding
(assert (HasKind Typ_fun_1192
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1192)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1192)))))
;;;;;;;;;;;;;;;;Typ_fun_1192 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1192)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.exp)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1192)))))
;;;;;;;;;;;;;;;;data constructor proxy: ELam
(declare-fun Test.ELam@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1195
(Term_constr_id Test.ELam@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Test.ELam@tok
Typ_fun_1192))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.ELam@tok
@x0)
(Test.ELam @x0))
  
:pattern ((ApplyEE Test.ELam@tok
@x0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Test.exp)
(HasTypeFuel @u0
(Test.ELam @x1)
Test.exp))
  
:pattern ((HasTypeFuel @u0
(Test.ELam @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)
(HasTypeFuel @u0
@x1
Test.exp))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)
(Valid (Precedes @x1
(Test.ELam @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)))))

; </end encoding Test.ELam>
(pop)

; Recursive bindings: Test.exp, Test.EVar, Test.EApp, Test.ELam

; encoding sigelt Test.exp, Test.EVar, Test.EApp, Test.ELam

; <Start encoding >

; <Start encoding Test.exp>

; <start constructor Test.exp>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.exp () Type)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (= 1196
(Type_constr_id Test.exp)))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.exp ((@a0 Type)) Bool
 (and (= (Type_constr_id @a0)
1196)
(= @a0
Test.exp)))

; </end constructor Test.exp>
;;;;;;;;;;;;;;;;kinding
(assert (HasKind Test.exp
Kind_type))
;;;;;;;;;;;;;;;;pretyping
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (implies (HasTypeFuel @u1
@x0
Test.exp)
(= Test.exp
(PreType @x0)))
  
:pattern ((HasTypeFuel @u1
@x0
Test.exp)))))

; </end encoding Test.exp>

; <Start encoding Test.EVar>

; <start constructor Test.EVar>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.EVar (Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term))
 (= 1202
(Term_constr_id (Test.EVar @x0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.EVar__0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term))
 (! (= (Test.EVar__0 (Test.EVar @x0))
@x0)
  
:pattern ((Test.EVar @x0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.EVar ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1202)
(= @x0
(Test.EVar (Test.EVar__0 @x0)))))

; </end constructor Test.EVar>
;;;;;;;;;;;;;;;;(_0:nat -> Tot exp)
(declare-fun Typ_fun_1204 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1204 kinding
(assert (HasKind Typ_fun_1204
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1204)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1204)))))
;;;;;;;;;;;;;;;;Typ_fun_1204 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1204)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Prims.nat@tok)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1204)))))
;;;;;;;;;;;;;;;;data constructor proxy: EVar
(declare-fun Test.EVar@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1207
(Term_constr_id Test.EVar@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Test.EVar@tok
Typ_fun_1204))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.EVar@tok
@x0)
(Test.EVar @x0))
  
:pattern ((ApplyEE Test.EVar@tok
@x0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Prims.nat@tok)
(HasTypeFuel @u0
(Test.EVar @x1)
Test.exp))
  
:pattern ((HasTypeFuel @u0
(Test.EVar @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)
(HasTypeFuel @u0
@x1
Prims.nat@tok))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)
(Valid (Precedes @x1
(Test.EVar @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EVar @x1)
Test.exp)))))

; </end encoding Test.EVar>

; <Start encoding Test.EApp>

; <start constructor Test.EApp>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.EApp (Term Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term) (@x1 Term))
 (= 1209
(Term_constr_id (Test.EApp @x0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.EApp__0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (Test.EApp__0 (Test.EApp @x0
@x1))
@x0)
  
:pattern ((Test.EApp @x0
@x1)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.EApp__1 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (Test.EApp__1 (Test.EApp @x0
@x1))
@x1)
  
:pattern ((Test.EApp @x0
@x1)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.EApp ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1209)
(= @x0
(Test.EApp (Test.EApp__0 @x0)
(Test.EApp__1 @x0)))))

; </end constructor Test.EApp>
;;;;;;;;;;;;;;;;(_0:exp -> _1:exp -> Tot exp)
(declare-fun Typ_fun_1211 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1211 kinding
(assert (HasKind Typ_fun_1211
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1211)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1211)))))
;;;;;;;;;;;;;;;;Typ_fun_1211 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1211)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Test.exp)
(HasType @x3
Test.exp))
(HasType (ApplyEE (ApplyEE @x1
@x2)
@x3)
Test.exp))
  
:pattern ((ApplyEE (ApplyEE @x1
@x2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1211)))))
;;;;;;;;;;;;;;;;data constructor proxy: EApp
(declare-fun Test.EApp@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1214
(Term_constr_id Test.EApp@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Test.EApp@tok
Typ_fun_1211))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Test.EApp@tok
@x0)
@x1)
(Test.EApp @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Test.EApp@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasTypeFuel (SFuel @u0)
@x1
Test.exp)
(HasTypeFuel (SFuel @u0)
@x2
Test.exp))
(HasTypeFuel @u0
(Test.EApp @x1
@x2)
Test.exp))
  
:pattern ((HasTypeFuel @u0
(Test.EApp @x1
@x2)
Test.exp)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)
(and (HasTypeFuel @u0
@x1
Test.exp)
(HasTypeFuel @u0
@x2
Test.exp)))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)
(and (Valid (Precedes @x1
(Test.EApp @x1
@x2)))
(Valid (Precedes @x2
(Test.EApp @x1
@x2)))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.EApp @x1
@x2)
Test.exp)))))

; </end encoding Test.EApp>

; <Start encoding Test.ELam>

; <start constructor Test.ELam>
;;;;;;;;;;;;;;;;Constructor
(declare-fun Test.ELam (Term) Term)
;;;;;;;;;;;;;;;;Constructor distinct
(assert (forall ((@x0 Term))
 (= 1216
(Term_constr_id (Test.ELam @x0)))))
;;;;;;;;;;;;;;;;Projector
(declare-fun Test.ELam__0 (Term) Term)
;;;;;;;;;;;;;;;;Projection inverse
(assert (forall ((@x0 Term))
 (! (= (Test.ELam__0 (Test.ELam @x0))
@x0)
  
:pattern ((Test.ELam @x0)))))
;;;;;;;;;;;;;;;;Discriminator definition
(define-fun is-Test.ELam ((@x0 Term)) Bool
 (and (= (Term_constr_id @x0)
1216)
(= @x0
(Test.ELam (Test.ELam__0 @x0)))))

; </end constructor Test.ELam>
;;;;;;;;;;;;;;;;(_0:exp -> Tot exp)
(declare-fun Typ_fun_1218 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1218 kinding
(assert (HasKind Typ_fun_1218
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1218)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1218)))))
;;;;;;;;;;;;;;;;Typ_fun_1218 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1218)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.exp)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1218)))))
;;;;;;;;;;;;;;;;data constructor proxy: ELam
(declare-fun Test.ELam@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1221
(Term_constr_id Test.ELam@tok)))
;;;;;;;;;;;;;;;;typing for data constructor proxy
(assert (HasType Test.ELam@tok
Typ_fun_1218))
;;;;;;;;;;;;;;;;equality for proxy
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.ELam@tok
@x0)
(Test.ELam @x0))
  
:pattern ((ApplyEE Test.ELam@tok
@x0)))))
;;;;;;;;;;;;;;;;data constructor typing intro
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Test.exp)
(HasTypeFuel @u0
(Test.ELam @x1)
Test.exp))
  
:pattern ((HasTypeFuel @u0
(Test.ELam @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;data constructor typing elim
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)
(HasTypeFuel @u0
@x1
Test.exp))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)))))
;;;;;;;;;;;;;;;;subterm ordering
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)
(Valid (Precedes @x1
(Test.ELam @x1))))
  
:pattern ((HasTypeFuel (SFuel @u0)
(Test.ELam @x1)
Test.exp)))))

; </end encoding Test.ELam>
;;;;;;;;;;;;;;;;inversion axiom
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasTypeFuel (SFuel @u0)
@x1
Test.exp)
(or (is-Test.EVar @x1)
(is-Test.EApp @x1)
(is-Test.ELam @x1)))
  
:pattern ((HasTypeFuel (SFuel @u0)
@x1
Test.exp)))))

; </end encoding >

; encoding sigelt Test.is_EVar

; <Start encoding Test.is_EVar>
(declare-fun Test.is_EVar (Term) Term)
;;;;;;;;;;;;;;;;(exp -> Tot bool)
(declare-fun Typ_fun_1223 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1223 kinding
(assert (HasKind Typ_fun_1223
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1223)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1223)))))
;;;;;;;;;;;;;;;;Typ_fun_1223 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1223)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.exp)
(HasType (ApplyEE @x1
@x2)
Prims.bool))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1223)))))
(declare-fun Test.is_EVar@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1226
(Term_constr_id Test.is_EVar@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.is_EVar@tok
@x0)
(Test.is_EVar @x0))
  
:pattern ((ApplyEE Test.is_EVar@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.is_EVar@tok
Typ_fun_1223))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(HasType (Test.is_EVar @x0)
Prims.bool))
  
:pattern ((Test.is_EVar @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.is_EVar @x0)
(BoxBool (is-Test.EVar @x0)))
  
:pattern ((Test.is_EVar @x0)))))

; </end encoding Test.is_EVar>

; encoding sigelt Test.is_EApp

; <Start encoding Test.is_EApp>
(declare-fun Test.is_EApp (Term) Term)
(declare-fun Test.is_EApp@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1228
(Term_constr_id Test.is_EApp@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.is_EApp@tok
@x0)
(Test.is_EApp @x0))
  
:pattern ((ApplyEE Test.is_EApp@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.is_EApp@tok
Typ_fun_1223))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(HasType (Test.is_EApp @x0)
Prims.bool))
  
:pattern ((Test.is_EApp @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.is_EApp @x0)
(BoxBool (is-Test.EApp @x0)))
  
:pattern ((Test.is_EApp @x0)))))

; </end encoding Test.is_EApp>

; encoding sigelt Test.is_ELam

; <Start encoding Test.is_ELam>
(declare-fun Test.is_ELam (Term) Term)
(declare-fun Test.is_ELam@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1230
(Term_constr_id Test.is_ELam@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.is_ELam@tok
@x0)
(Test.is_ELam @x0))
  
:pattern ((ApplyEE Test.is_ELam@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.is_ELam@tok
Typ_fun_1223))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(HasType (Test.is_ELam @x0)
Prims.bool))
  
:pattern ((Test.is_ELam @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.is_ELam @x0)
(BoxBool (is-Test.ELam @x0)))
  
:pattern ((Test.is_ELam @x0)))))

; </end encoding Test.is_ELam>
(push)

; Starting query at bug281.fst(14,2-14,6)
(pop)

; Ending query at bug281.fst(14,2-14,6)

; encoding sigelt Test.EVar._0

; <Start encoding Test.EVar._0>
(declare-fun Typ_refine_1231 () Type)
(assert (HasKind Typ_refine_1231
Kind_type))
;;;;;;;;;;;;;;;;_2_2:exp{(is_EVar _2_2)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1231)
(and (HasType @x1
Test.exp)
(Valid (Prims.b2t (Test.is_EVar @x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1231)))))
(declare-fun Test.EVar._0 (Term) Term)
;;;;;;;;;;;;;;;;(projectee:_2_2:exp{(is_EVar _2_2)} -> Tot nat)
(declare-fun Typ_fun_1234 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1234 kinding
(assert (HasKind Typ_fun_1234
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1234)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1234)))))
;;;;;;;;;;;;;;;;Typ_fun_1234 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1234)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1231)
(HasType (ApplyEE @x1
@x2)
Prims.nat@tok))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1234)))))
(declare-fun Test.EVar._0@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1237
(Term_constr_id Test.EVar._0@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.EVar._0@tok
@x0)
(Test.EVar._0 @x0))
  
:pattern ((ApplyEE Test.EVar._0@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.EVar._0@tok
Typ_fun_1234))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1231)
(HasType (Test.EVar._0 @x0)
Prims.nat@tok))
  
:pattern ((Test.EVar._0 @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.EVar._0 @x0)
(Test.EVar__0 @x0))
  
:pattern ((Test.EVar._0 @x0)))))

; </end encoding Test.EVar._0>
(push)

; Starting query at bug281.fst(14,2-14,6)
(pop)

; Ending query at bug281.fst(14,2-14,6)

; encoding sigelt Test.EApp._0

; <Start encoding Test.EApp._0>
(declare-fun Typ_refine_1238 () Type)
(assert (HasKind Typ_refine_1238
Kind_type))
;;;;;;;;;;;;;;;;_2_4:exp{(is_EApp _2_4)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1238)
(and (HasType @x1
Test.exp)
(Valid (Prims.b2t (Test.is_EApp @x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1238)))))
(declare-fun Test.EApp._0 (Term) Term)
;;;;;;;;;;;;;;;;(projectee:_2_4:exp{(is_EApp _2_4)} -> Tot exp)
(declare-fun Typ_fun_1241 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1241 kinding
(assert (HasKind Typ_fun_1241
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1241)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1241)))))
;;;;;;;;;;;;;;;;Typ_fun_1241 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1241)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1238)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1241)))))
(declare-fun Test.EApp._0@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1244
(Term_constr_id Test.EApp._0@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.EApp._0@tok
@x0)
(Test.EApp._0 @x0))
  
:pattern ((ApplyEE Test.EApp._0@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.EApp._0@tok
Typ_fun_1241))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1238)
(HasType (Test.EApp._0 @x0)
Test.exp))
  
:pattern ((Test.EApp._0 @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.EApp._0 @x0)
(Test.EApp__0 @x0))
  
:pattern ((Test.EApp._0 @x0)))))

; </end encoding Test.EApp._0>
(push)

; Starting query at bug281.fst(14,2-14,6)
(pop)

; Ending query at bug281.fst(14,2-14,6)

; encoding sigelt Test.EApp._1

; <Start encoding Test.EApp._1>
(declare-fun Test.EApp._1 (Term) Term)
(declare-fun Test.EApp._1@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1246
(Term_constr_id Test.EApp._1@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.EApp._1@tok
@x0)
(Test.EApp._1 @x0))
  
:pattern ((ApplyEE Test.EApp._1@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.EApp._1@tok
Typ_fun_1241))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1238)
(HasType (Test.EApp._1 @x0)
Test.exp))
  
:pattern ((Test.EApp._1 @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.EApp._1 @x0)
(Test.EApp__1 @x0))
  
:pattern ((Test.EApp._1 @x0)))))

; </end encoding Test.EApp._1>
(push)

; Starting query at bug281.fst(14,2-14,6)
(pop)

; Ending query at bug281.fst(14,2-14,6)

; encoding sigelt Test.ELam._0

; <Start encoding Test.ELam._0>
(declare-fun Typ_refine_1247 () Type)
(assert (HasKind Typ_refine_1247
Kind_type))
;;;;;;;;;;;;;;;;_2_6:exp{(is_ELam _2_6)}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1247)
(and (HasType @x1
Test.exp)
(Valid (Prims.b2t (Test.is_ELam @x1)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1247)))))
(declare-fun Test.ELam._0 (Term) Term)
;;;;;;;;;;;;;;;;(projectee:_2_6:exp{(is_ELam _2_6)} -> Tot exp)
(declare-fun Typ_fun_1250 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1250 kinding
(assert (HasKind Typ_fun_1250
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1250)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1250)))))
;;;;;;;;;;;;;;;;Typ_fun_1250 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1250)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1247)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1250)))))
(declare-fun Test.ELam._0@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1253
(Term_constr_id Test.ELam._0@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.ELam._0@tok
@x0)
(Test.ELam._0 @x0))
  
:pattern ((ApplyEE Test.ELam._0@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.ELam._0@tok
Typ_fun_1250))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1247)
(HasType (Test.ELam._0 @x0)
Test.exp))
  
:pattern ((Test.ELam._0 @x0)))))
(assert (forall ((@x0 Term))
 (! (= (Test.ELam._0 @x0)
(Test.ELam__0 @x0))
  
:pattern ((Test.ELam._0 @x0)))))

; </end encoding Test.ELam._0>

; encoding sigelt Test.sub

; <Start encoding Test.sub>
(declare-fun Test.sub () Type)
(declare-fun Test.sub@tok () Type)
;;;;;;;;;;;;;;;;name-token correspondence
(assert (= Test.sub@tok
Test.sub))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (= Test.sub
Typ_fun_1204))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (HasKind Test.sub
Kind_type))

; </end encoding Test.sub>
(push)

; Starting query at bug281.fst(16,27-18,49)
(pop)

; Ending query at bug281.fst(16,27-18,49)

; encoding sigelt Test.renaming

; <Start encoding Test.renaming>
(declare-fun Test.renaming (Term) Type)
(declare-fun Test.renaming@tok () Type)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1259
(Type_constr_id Test.renaming@tok)))
;;;;;;;;;;;;;;;;name-token correspondence
(assert (forall ((@x0 Term))
 (! (= (ApplyTE Test.renaming@tok
@x0)
(Test.renaming @x0))
  
:pattern ((ApplyTE Test.renaming@tok
@x0)))))
;;;;;;;;;;;;;;;;abbrev. elimination
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.sub@tok)
(= (Valid (Test.renaming @x0))
(forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x0
@x1))))))))
  
:pattern ((Valid (Test.renaming @x0))))))
;;;;;;;;;;;;;;;;abbrev. kinding
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.sub@tok)
(HasKind (Test.renaming @x0)
Kind_type))
  
:pattern ((Test.renaming @x0)))))

; </end encoding Test.renaming>

; encoding sigelt Test.is_renaming

; <Start encoding Test.is_renaming>
(declare-fun Test.is_renaming (Term) Term)
;;;;;;;;;;;;;;;;(s:sub -> Tot nat)
(declare-fun Typ_fun_1261 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1261 kinding
(assert (HasKind Typ_fun_1261
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1261)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1261)))))
;;;;;;;;;;;;;;;;Typ_fun_1261 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1261)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.sub@tok)
(HasType (ApplyEE @x1
@x2)
Prims.nat@tok))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1261)))))
(declare-fun Test.is_renaming@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1264
(Term_constr_id Test.is_renaming@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.is_renaming@tok
@x0)
(Test.is_renaming @x0))
  
:pattern ((ApplyEE Test.is_renaming@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.is_renaming@tok
Typ_fun_1261))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.sub@tok)
(HasType (Test.is_renaming @x0)
Prims.nat@tok))
  
:pattern ((Test.is_renaming @x0)))))

; </end encoding Test.is_renaming>
(push)

; Starting query at bug281.fst(21,0-22,49)
;;;;;;;;;;;;;;;;s : sub ((i:int{(i >= 0)} -> Tot exp))
(declare-fun s___2_10 () Term)
;;;;;;;;;;;;;;;;(i:int{(i >= 0)} -> Tot exp)
(declare-fun Typ_fun_1266 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1266 kinding
(assert (HasKind Typ_fun_1266
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1266)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1266)))))
;;;;;;;;;;;;;;;;Typ_fun_1266 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1266)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1144)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1266)))))
(assert (HasType s___2_10
Typ_fun_1266))
(declare-fun label_1270 () Bool)
(declare-fun label_1271 () Bool)
(declare-fun label_1272 () Bool)
(declare-fun Typ_lam_1269 () Type)
;;;;;;;;;;;;;;;;Typ_lam interpretation
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1144)
(= (ApplyTE Typ_lam_1269
@x0)
(Prims.b2t (Test.is_EVar (ApplyEE s___2_10
@x0)))))
  
:pattern ((ApplyTE Typ_lam_1269
@x0)))))
;;;;;;;;;;;;;;;;Typ_lam kinding
(assert (and (is-Kind_arrow (PreKind Typ_lam_1269))
(forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1144)
(HasKind (ApplyTE Typ_lam_1269
@x0)
Kind_type))
  
:pattern ((ApplyTE Typ_lam_1269
@x0))))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (ite (= (Classical.excluded_middle (Prims.Forall Typ_refine_1144
Typ_lam_1269))
(BoxBool true))
(or label_1270
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 0)
(BoxInt 0)))))
(ite (= (Classical.excluded_middle (Prims.Forall Typ_refine_1144
Typ_lam_1269))
(BoxBool false))
(or label_1271
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 1)
(BoxInt 0)))))
label_1272))))
(check-sat)
(echo "label_1270")
(eval label_1270)
(echo "label_1271")
(eval label_1271)
(echo "label_1272")
(eval label_1272)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(21,0-22,49)

; encoding sigelt let Test.is_renaming : (s:sub -> Tot nat)

; <Start encoding Test.is_renaming>
;;;;;;;;;;;;;;;;Equation for Test.is_renaming
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.sub@tok)
(= (Test.is_renaming @x0)
(ite (= (Classical.excluded_middle (Test.renaming @x0))
(BoxBool true))
(BoxInt 0)
(ite (= (Classical.excluded_middle (Test.renaming @x0))
(BoxBool false))
(BoxInt 1)
Term_unit))))
  
:pattern ((Test.is_renaming @x0)))))

; </end encoding Test.is_renaming>

; encoding sigelt Test.is_evar

; <Start encoding Test.is_evar>
(declare-fun Test.is_evar (Term) Term)
;;;;;;;;;;;;;;;;(exp -> Tot nat)
(declare-fun Typ_fun_1274 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1274 kinding
(assert (HasKind Typ_fun_1274
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1274)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1274)))))
;;;;;;;;;;;;;;;;Typ_fun_1274 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1274)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.exp)
(HasType (ApplyEE @x1
@x2)
Prims.nat@tok))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1274)))))
(declare-fun Test.is_evar@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1277
(Term_constr_id Test.is_evar@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.is_evar@tok
@x0)
(Test.is_evar @x0))
  
:pattern ((ApplyEE Test.is_evar@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.is_evar@tok
Typ_fun_1274))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(HasType (Test.is_evar @x0)
Prims.nat@tok))
  
:pattern ((Test.is_evar @x0)))))

; </end encoding Test.is_evar>
(push)

; Starting query at bug281.fst(25,0-25,44)
;;;;;;;;;;;;;;;;e : exp (exp)
(declare-fun e___2_11 () Term)
(assert (HasType e___2_11
Test.exp))
(declare-fun label_1278 () Bool)
(declare-fun label_1279 () Bool)
(declare-fun label_1280 () Bool)
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (ite (= (Test.is_EVar e___2_11)
(BoxBool true))
(or label_1278
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 0)
(BoxInt 0)))))
(ite (= (Test.is_EVar e___2_11)
(BoxBool false))
(or label_1279
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 1)
(BoxInt 0)))))
label_1280))))
(check-sat)
(echo "label_1278")
(eval label_1278)
(echo "label_1279")
(eval label_1279)
(echo "label_1280")
(eval label_1280)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(25,0-25,44)

; encoding sigelt let Test.is_evar : (exp -> Tot nat)

; <Start encoding Test.is_evar>
;;;;;;;;;;;;;;;;Equation for Test.is_evar
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(= (Test.is_evar @x0)
(ite (= (Test.is_EVar @x0)
(BoxBool true))
(BoxInt 0)
(ite (= (Test.is_EVar @x0)
(BoxBool false))
(BoxInt 1)
Term_unit))))
  
:pattern ((Test.is_evar @x0)))))

; </end encoding Test.is_evar>

; encoding sigelt Test.sub_einc

; <Start encoding Test.sub_einc>
(declare-fun Test.sub_einc (Term) Term)
(declare-fun Test.sub_einc@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1282
(Term_constr_id Test.sub_einc@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.sub_einc@tok
@x0)
(Test.sub_einc @x0))
  
:pattern ((ApplyEE Test.sub_einc@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.sub_einc@tok
Typ_fun_1204))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.nat@tok)
(HasType (Test.sub_einc @x0)
Test.exp))
  
:pattern ((Test.sub_einc @x0)))))

; </end encoding Test.sub_einc>
(push)

; Starting query at bug281.fst(28,0-28,27)
;;;;;;;;;;;;;;;;x : nat (i:int{(i >= 0)})
(declare-fun x___2_12 () Term)
(assert (HasType x___2_12
Typ_refine_1144))
(declare-fun label_1283 () Bool)
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (or label_1283
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (Prims.op_Addition x___2_12
(BoxInt 1))
(BoxInt 0)))))))
(check-sat)
(echo "label_1283")
(eval label_1283)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(28,0-28,27)

; encoding sigelt let Test.sub_einc : (nat -> Tot exp)

; <Start encoding Test.sub_einc>
;;;;;;;;;;;;;;;;Equation for Test.sub_einc
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Prims.nat@tok)
(= (Test.sub_einc @x0)
(Test.EVar (Prims.op_Addition @x0
(BoxInt 1)))))
  
:pattern ((Test.sub_einc @x0)))))

; </end encoding Test.sub_einc>
(push)

; Starting query at bug281.fst(28,27-31,44)
(pop)

; Ending query at bug281.fst(28,27-31,44)

; encoding sigelt Test.esubst

; <Start encoding Test.esubst>
(declare-fun Test.esubst (Term Term) Term)
(declare-fun Typ_refine_1289 (Term Term) Type)
(assert (forall ((@x0 Term) (@x1 Term))
 (! (HasKind (Typ_refine_1289 @x0
@x1)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1289 @x0
@x1)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((renaming s) /\ (is_EVar e)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasType @x1
(Typ_refine_1289 @x2
@x3))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x4 Term))
 (implies (HasType @x4
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x3
@x4))))))
(Valid (Prims.b2t (Test.is_EVar @x2))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1289 @x2
@x3))))))
;;;;;;;;;;;;;;;;(s:sub -> e:exp -> Tot r:exp{(((renaming s) /\ (is_EVar e)) ==> (is_EVar r))} (decreases %[(is_evar e); (is_renaming s); 1; e]))
(declare-fun Typ_fun_1291 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1291 kinding
(assert (HasKind Typ_fun_1291
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1291)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1291)))))
;;;;;;;;;;;;;;;;Typ_fun_1291 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1291)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Test.sub@tok)
(HasType @x3
Test.exp))
(HasType (ApplyEE (ApplyEE @x1
@x2)
@x3)
(Typ_refine_1289 @x3
@x2)))
  
:pattern ((ApplyEE (ApplyEE @x1
@x2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1291)))))
(declare-fun Test.esubst@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1294
(Term_constr_id Test.esubst@tok)))
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Test.esubst@tok
@x0)
@x1)
(Test.esubst @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Test.esubst@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.esubst@tok
Typ_fun_1291))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Test.sub@tok)
(HasType @x1
Test.exp))
(HasType (Test.esubst @x0
@x1)
(Typ_refine_1289 @x1
@x0)))
  
:pattern ((Test.esubst @x0
@x1)))))

; </end encoding Test.esubst>
(push)

; Starting query at bug281.fst(31,44-33,41)
(declare-fun label_1299 () Bool)
;;;;;;;;;;;;;;;;(i:int{(i >= 0)} -> Tot exp)
(declare-fun Typ_fun_1296 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1296 kinding
(assert (HasKind Typ_fun_1296
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1296)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1296)))))
;;;;;;;;;;;;;;;;Typ_fun_1296 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1296)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1144)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1296)))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@x0 Term))
 (implies (HasType @x0
Typ_fun_1296)
(or label_1299
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 0)
(BoxInt 0)))))))))
(check-sat)
(echo "label_1299")
(eval label_1299)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(31,44-33,41)

; encoding sigelt Test.sub_elam

; <Start encoding Test.sub_elam>
(declare-fun Test.sub_elam (Term) Term)
;;;;;;;;;;;;;;;;(i:int{(i >= 0)} -> Tot exp)
(declare-fun Typ_fun_1302 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1302 kinding
(assert (HasKind Typ_fun_1302
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1302)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1302)))))
;;;;;;;;;;;;;;;;Typ_fun_1302 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1302)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1144)
(HasType (ApplyEE @x1
@x2)
Test.exp))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1302)))))
(declare-fun Typ_refine_1305 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1305 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1305 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:sub{((renaming s) ==> (renaming r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1305 @x2))
(and (HasType @x1
Typ_fun_1302)
(implies (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x2
@x3))))))
(forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x1
@x3)))))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1305 @x2))))))
;;;;;;;;;;;;;;;;(s:sub -> Tot r:sub{((renaming s) ==> (renaming r))} (decreases %[1; (is_renaming s); 0; (EVar 0)]))
(declare-fun Typ_fun_1307 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1307 kinding
(assert (HasKind Typ_fun_1307
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1307)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1307)))))
;;;;;;;;;;;;;;;;Typ_fun_1307 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1307)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.sub@tok)
(HasType (ApplyEE @x1
@x2)
(Typ_refine_1305 @x2)))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1307)))))
(declare-fun Test.sub_elam@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1310
(Term_constr_id Test.sub_elam@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.sub_elam@tok
@x0)
(Test.sub_elam @x0))
  
:pattern ((ApplyEE Test.sub_elam@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.sub_elam@tok
Typ_fun_1307))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.sub@tok)
(HasType (Test.sub_elam @x0)
(Typ_refine_1305 @x0)))
  
:pattern ((Test.sub_elam @x0)))))

; </end encoding Test.sub_elam>
(push)

; Starting query at bug281.fst(35,0-43,48)
;;;;;;;;;;;;;;;;s : sub ((i:int{(i >= 0)} -> Tot exp))
(declare-fun s___2_18 () Term)
(assert (HasType s___2_18
Typ_fun_1302))
(declare-fun Typ_refine_1314 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1314 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1314 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;_2_969:exp{(%[(is_evar _2_969); (is_renaming s); 1; _2_969] << %[1; (is_renaming s); 0; (EVar 0)])}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1314 @x2))
(and (HasType @x1
Test.exp)
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (Test.is_evar @x1)
(LexCons (Test.is_renaming @x2)
(LexCons (BoxInt 1)
(LexCons @x1
Prims.LexTop@tok))))
(LexCons (BoxInt 1)
(LexCons (Test.is_renaming s___2_18)
(LexCons (BoxInt 0)
(LexCons (Test.EVar (BoxInt 0))
Prims.LexTop@tok))))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1314 @x2))))))
(declare-fun Test.esubst__1313 (Term Term) Term)
;;;;;;;;;;;;;;;;(s:sub -> e:_2_969:exp{(%[(is_evar _2_969); (is_renaming s); 1; _2_969] << %[1; (is_renaming s); 0; (EVar 0)])} -> Tot r:exp{(((renaming s) /\ (is_EVar e)) ==> (is_EVar r))} (decreases %[(is_evar e); (is_renaming s); 1; e]))
(declare-fun Typ_fun_1317 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1317 kinding
(assert (HasKind Typ_fun_1317
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1317)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1317)))))
;;;;;;;;;;;;;;;;Typ_fun_1317 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1317)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Test.sub@tok)
(HasType @x3
(Typ_refine_1314 @x2)))
(HasType (ApplyEE (ApplyEE @x1
@x2)
@x3)
(Typ_refine_1289 @x3
@x2)))
  
:pattern ((ApplyEE (ApplyEE @x1
@x2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1317)))))
(declare-fun Test.esubst__1313@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1320
(Term_constr_id Test.esubst__1313@tok)))
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Test.esubst__1313@tok
@x0)
@x1)
(Test.esubst__1313 @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Test.esubst__1313@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.esubst__1313@tok
Typ_fun_1317))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Test.sub@tok)
(HasType @x1
(Typ_refine_1314 @x0)))
(HasType (Test.esubst__1313 @x0
@x1)
(Typ_refine_1289 @x1
@x0)))
  
:pattern ((Test.esubst__1313 @x0
@x1)))))
(declare-fun Typ_refine_1323 () Type)
(assert (HasKind Typ_refine_1323
Kind_type))
;;;;;;;;;;;;;;;;_2_1279:sub{(%[1; (is_renaming _2_1279); 0; (EVar 0)] << %[1; (is_renaming s); 0; (EVar 0)])}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1323)
(and (HasType @x1
Typ_fun_1302)
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (BoxInt 1)
(LexCons (Test.is_renaming @x1)
(LexCons (BoxInt 0)
(LexCons (Test.EVar (BoxInt 0))
Prims.LexTop@tok))))
(LexCons (BoxInt 1)
(LexCons (Test.is_renaming s___2_18)
(LexCons (BoxInt 0)
(LexCons (Test.EVar (BoxInt 0))
Prims.LexTop@tok))))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1323)))))
(declare-fun Test.sub_elam__1321 (Term) Term)
;;;;;;;;;;;;;;;;(s:_2_1279:sub{(%[1; (is_renaming _2_1279); 0; (EVar 0)] << %[1; (is_renaming s); 0; (EVar 0)])} -> Tot r:sub{((renaming s) ==> (renaming r))} (decreases %[1; (is_renaming s); 0; (EVar 0)]))
(declare-fun Typ_fun_1328 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1328 kinding
(assert (HasKind Typ_fun_1328
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1328)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1328)))))
;;;;;;;;;;;;;;;;Typ_fun_1328 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1328)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1323)
(HasType (ApplyEE @x1
@x2)
(Typ_refine_1305 @x2)))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1328)))))
(declare-fun Test.sub_elam__1321@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1331
(Term_constr_id Test.sub_elam__1321@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.sub_elam__1321@tok
@x0)
(Test.sub_elam__1321 @x0))
  
:pattern ((ApplyEE Test.sub_elam__1321@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.sub_elam__1321@tok
Typ_fun_1328))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1323)
(HasType (Test.sub_elam__1321 @x0)
(Typ_refine_1305 @x0)))
  
:pattern ((Test.sub_elam__1321 @x0)))))
(declare-fun label_1334 () Bool)
(declare-fun label_1339 () Bool)
(declare-fun label_1338 () Bool)
(declare-fun label_1337 () Bool)
(declare-fun label_1340 () Bool)
(declare-fun label_1333 () Bool)
(declare-fun Typ_refine_1335 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1335 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1335 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar (s (x - 1)))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1335 @x2))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x3))))))
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_18
(Prims.op_Subtraction @x2
(BoxInt 1)))))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1335 @x2))))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (and (forall ((@x0 Term))
 (implies (and (HasType @x0
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0))))))
(forall ((@x0 Term))
 (implies (and (HasType @x0
Typ_fun_1302)
(implies (forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_18
@x1))))))
(forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x0
@x1)))))))
(forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_18
@x1)))))))
(forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x0
@x1))))))))
(forall ((@x0 Term) (@x1 Term))
 (implies (and (HasType @x0
Typ_refine_1144)
(HasType @x1
Prims.bool)
(= @x1
(Prims.op_Equality Prims.int
@x0
(BoxInt 0))))
(ite (= @x1
(BoxBool true))
(or label_1334
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 0)
(BoxInt 0)))))
(ite (= @x1
(BoxBool false))
(and (or label_1339
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(or label_1338
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (Prims.op_Subtraction @x0
(BoxInt 1))
(BoxInt 0)))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
Test.exp)
(= @x2
(ApplyEE s___2_18
(Prims.op_Subtraction @x0
(BoxInt 1)))))
(or label_1337
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (Test.is_evar @x2)
(LexCons (Test.is_renaming Test.sub_einc@tok)
(LexCons (BoxInt 1)
(LexCons @x2
Prims.LexTop@tok))))
(LexCons (BoxInt 1)
(LexCons (Test.is_renaming s___2_18)
(LexCons (BoxInt 0)
(LexCons (Test.EVar (BoxInt 0))
Prims.LexTop@tok))))))))))
label_1340))))
(or label_1333
(and (forall ((@x0 Term))
 (implies (and (HasType @x0
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0))))))
(implies (forall ((@x0 Term))
 (implies (HasType @x0
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_18
@x0))))))
(forall ((@x0 Term))
 (implies (HasType @x0
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ite (= (Prims.op_Equality Prims.int
@x0
(BoxInt 0))
(BoxBool true))
(Test.EVar (BoxInt 0))
(ite (= (Prims.op_Equality Prims.int
@x0
(BoxInt 0))
(BoxBool false))
(Test.esubst__1313 Test.sub_einc@tok
(ApplyEE s___2_18
(Prims.op_Subtraction @x0
(BoxInt 1))))
Term_unit)))))))))))))
(check-sat)
(echo "label_1334")
(eval label_1334)
(echo "label_1339")
(eval label_1339)
(echo "label_1338")
(eval label_1338)
(echo "label_1337")
(eval label_1337)
(echo "label_1340")
(eval label_1340)
(echo "label_1333")
(eval label_1333)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(35,0-43,48)
(push)

; Starting query at bug281.fst(35,0-43,48)
;;;;;;;;;;;;;;;;s : sub ((i:int{(i >= 0)} -> Tot exp))
(declare-fun s___2_21 () Term)
(assert (HasType s___2_21
Typ_fun_1302))
;;;;;;;;;;;;;;;;e : exp (exp)
(declare-fun e___2_22 () Term)
(assert (HasType e___2_22
Test.exp))
(declare-fun Typ_refine_1344 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1344 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1344 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;_2_2587:exp{(%[(is_evar _2_2587); (is_renaming s); 1; _2_2587] << %[(is_evar e); (is_renaming s); 1; e])}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1344 @x2))
(and (HasType @x1
Test.exp)
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (Test.is_evar @x1)
(LexCons (Test.is_renaming @x2)
(LexCons (BoxInt 1)
(LexCons @x1
Prims.LexTop@tok))))
(LexCons (Test.is_evar e___2_22)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons e___2_22
Prims.LexTop@tok))))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1344 @x2))))))
(declare-fun Test.esubst__1343 (Term Term) Term)
;;;;;;;;;;;;;;;;(s:sub -> e:_2_2587:exp{(%[(is_evar _2_2587); (is_renaming s); 1; _2_2587] << %[(is_evar e); (is_renaming s); 1; e])} -> Tot r:exp{(((renaming s) /\ (is_EVar e)) ==> (is_EVar r))} (decreases %[(is_evar e); (is_renaming s); 1; e]))
(declare-fun Typ_fun_1347 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1347 kinding
(assert (HasKind Typ_fun_1347
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1347)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1347)))))
;;;;;;;;;;;;;;;;Typ_fun_1347 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1347)
(forall ((@x2 Term) (@x3 Term))
 (! (implies (and (HasType @x2
Test.sub@tok)
(HasType @x3
(Typ_refine_1344 @x2)))
(HasType (ApplyEE (ApplyEE @x1
@x2)
@x3)
(Typ_refine_1289 @x3
@x2)))
  
:pattern ((ApplyEE (ApplyEE @x1
@x2)
@x3)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1347)))))
(declare-fun Test.esubst__1343@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1350
(Term_constr_id Test.esubst__1343@tok)))
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (ApplyEE (ApplyEE Test.esubst__1343@tok
@x0)
@x1)
(Test.esubst__1343 @x0
@x1))
  
:pattern ((ApplyEE (ApplyEE Test.esubst__1343@tok
@x0)
@x1)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.esubst__1343@tok
Typ_fun_1347))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term) (@x1 Term))
 (! (implies (and (HasType @x0
Test.sub@tok)
(HasType @x1
(Typ_refine_1344 @x0)))
(HasType (Test.esubst__1343 @x0
@x1)
(Typ_refine_1289 @x1
@x0)))
  
:pattern ((Test.esubst__1343 @x0
@x1)))))
(declare-fun Typ_refine_1353 () Type)
(assert (HasKind Typ_refine_1353
Kind_type))
;;;;;;;;;;;;;;;;_2_2943:sub{(%[1; (is_renaming _2_2943); 0; (EVar 0)] << %[(is_evar e); (is_renaming s); 1; e])}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1353)
(and (HasType @x1
Typ_fun_1302)
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (BoxInt 1)
(LexCons (Test.is_renaming @x1)
(LexCons (BoxInt 0)
(LexCons (Test.EVar (BoxInt 0))
Prims.LexTop@tok))))
(LexCons (Test.is_evar e___2_22)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons e___2_22
Prims.LexTop@tok))))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1353)))))
(declare-fun Test.sub_elam__1351 (Term) Term)
;;;;;;;;;;;;;;;;(s:_2_2943:sub{(%[1; (is_renaming _2_2943); 0; (EVar 0)] << %[(is_evar e); (is_renaming s); 1; e])} -> Tot r:sub{((renaming s) ==> (renaming r))} (decreases %[1; (is_renaming s); 0; (EVar 0)]))
(declare-fun Typ_fun_1358 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1358 kinding
(assert (HasKind Typ_fun_1358
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1358)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1358)))))
;;;;;;;;;;;;;;;;Typ_fun_1358 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1358)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Typ_refine_1353)
(HasType (ApplyEE @x1
@x2)
(Typ_refine_1305 @x2)))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1358)))))
(declare-fun Test.sub_elam__1351@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1361
(Term_constr_id Test.sub_elam__1351@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.sub_elam__1351@tok
@x0)
(Test.sub_elam__1351 @x0))
  
:pattern ((ApplyEE Test.sub_elam__1351@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.sub_elam__1351@tok
Typ_fun_1358))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Typ_refine_1353)
(HasType (Test.sub_elam__1351 @x0)
(Typ_refine_1305 @x0)))
  
:pattern ((Test.sub_elam__1351 @x0)))))
(declare-fun label_1364 () Bool)
(declare-fun label_1363 () Bool)
(declare-fun label_1369 () Bool)
(declare-fun label_1368 () Bool)
(declare-fun label_1367 () Bool)
(declare-fun label_1378 () Bool)
(declare-fun label_1377 () Bool)
(declare-fun label_1376 () Bool)
(declare-fun label_1375 () Bool)
(declare-fun label_1379 () Bool)
(declare-fun Typ_refine_1380 () Type)
(assert (HasKind Typ_refine_1380
Kind_type))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (s x))) /\ (is_EVar e)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1380)
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x2))))))
(Valid (Prims.b2t (Test.is_EVar e___2_22))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1380)))))
(declare-fun Typ_refine_1365 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1365 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1365 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (s x))) /\ (is_EVar b)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1365 @x2))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x3))))))
(Valid (Prims.b2t (Test.is_EVar @x2))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1365 @x2))))))
(declare-fun Typ_refine_1371 () Type)
(assert (HasKind Typ_refine_1371
Kind_type))
;;;;;;;;;;;;;;;;r:(i:int{(i >= 0)} -> Tot exp){((forall (x). (is_EVar (s x))) ==> (forall (x). (is_EVar (r x))))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1371)
(and (HasType @x1
Typ_fun_1302)
(implies (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x2))))))
(forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x1
@x2)))))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1371)))))
(declare-fun Typ_refine_1373 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1373 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1373 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_elam s x))) /\ (is_EVar b)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1373 @x2))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE (ApplyEE Test.sub_elam__1351@tok
s___2_21)
@x3))))))
(Valid (Prims.b2t (Test.is_EVar @x2))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1373 @x2))))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (and (forall ((@x0 Term))
 (implies (and (HasType @x0
Test.exp)
(implies (and (forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x1))))))
(Valid (Prims.b2t (Test.is_EVar e___2_22))))
(Valid (Prims.b2t (Test.is_EVar @x0))))
(forall ((@x1 Term))
 (implies (HasType @x1
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x1))))))
(Valid (Prims.b2t (Test.is_EVar e___2_22))))
(Valid (Prims.b2t (Test.is_EVar @x0)))))
(ite (= (Test.is_EVar e___2_22)
(BoxBool true))
(forall ((@x0 Term))
 (implies (and (HasType @x0
Typ_refine_1144)
(= e___2_22
(Test.EVar @x0)))
(and (or label_1364
(implies (Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0))))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Test.exp)
(= @x1
(ApplyEE s___2_21
@x0)))
(or label_1363
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x2))))))
(Valid (Prims.b2t (Test.is_EVar e___2_22))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))))))
(ite (= (Test.is_EApp e___2_22)
(BoxBool true))
(forall ((@x0 Term) (@x1 Term))
 (implies (and (HasType @x0
Test.exp)
(HasType @x1
Test.exp)
(= e___2_22
(Test.EApp @x0
@x1)))
(and (or label_1369
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (Test.is_evar @x0)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons @x0
Prims.LexTop@tok))))
(LexCons (Test.is_evar e___2_22)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons e___2_22
Prims.LexTop@tok)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
(Typ_refine_1365 @x0))
(= @x2
(Test.esubst__1343 s___2_21
@x0)))
(and (or label_1368
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (Test.is_evar @x1)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons @x1
Prims.LexTop@tok))))
(LexCons (Test.is_evar e___2_22)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons e___2_22
Prims.LexTop@tok)))))))
(forall ((@x3 Term))
 (implies (and (HasType @x3
(Typ_refine_1365 @x1))
(= @x3
(Test.esubst__1343 s___2_21
@x1)))
(forall ((@x4 Term))
 (implies (and (HasType @x4
Test.exp)
(= @x4
(Test.EApp (Test.esubst__1343 s___2_21
@x0)
(Test.esubst__1343 s___2_21
@x1))))
(or label_1367
(implies (and (forall ((@x5 Term))
 (implies (HasType @x5
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x5))))))
(Valid (Prims.b2t (Test.is_EVar e___2_22))))
(Valid (Prims.b2t (Test.is_EVar @x4)))))))))))))))
(ite (= (Test.is_ELam e___2_22)
(BoxBool true))
(forall ((@x0 Term))
 (implies (and (HasType @x0
Test.exp)
(= e___2_22
(Test.ELam @x0)))
(and (or label_1378
(and (forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0))))))
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (BoxInt 1)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 0)
(LexCons (Test.EVar (BoxInt 0))
Prims.LexTop@tok))))
(LexCons (Test.is_evar e___2_22)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons e___2_22
Prims.LexTop@tok))))))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Typ_refine_1371)
(= @x1
(Test.sub_elam__1351 s___2_21)))
(and (or label_1377
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(or label_1376
(Valid (Prims.Precedes Prims.lex_t
Prims.lex_t
(LexCons (Test.is_evar @x0)
(LexCons (Test.is_renaming (Test.sub_elam__1351 s___2_21))
(LexCons (BoxInt 1)
(LexCons @x0
Prims.LexTop@tok))))
(LexCons (Test.is_evar e___2_22)
(LexCons (Test.is_renaming s___2_21)
(LexCons (BoxInt 1)
(LexCons e___2_22
Prims.LexTop@tok)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
(Typ_refine_1373 @x0))
(= @x2
(Test.esubst__1343 (Test.sub_elam__1351 s___2_21)
@x0)))
(forall ((@x3 Term))
 (implies (and (HasType @x3
Test.exp)
(= @x3
(Test.ELam (Test.esubst__1343 (Test.sub_elam__1351 s___2_21)
@x0))))
(or label_1375
(implies (and (forall ((@x4 Term))
 (implies (HasType @x4
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE s___2_21
@x4))))))
(Valid (Prims.b2t (Test.is_EVar e___2_22))))
(Valid (Prims.b2t (Test.is_EVar @x3)))))))))))))))
label_1379))))))
(check-sat)
(echo "label_1364")
(eval label_1364)
(echo "label_1363")
(eval label_1363)
(echo "label_1369")
(eval label_1369)
(echo "label_1368")
(eval label_1368)
(echo "label_1367")
(eval label_1367)
(echo "label_1378")
(eval label_1378)
(echo "label_1377")
(eval label_1377)
(echo "label_1376")
(eval label_1376)
(echo "label_1375")
(eval label_1375)
(echo "label_1379")
(eval label_1379)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(35,0-43,48)

; encoding sigelt Test.sub_elam, Test.esubst

; <Start encoding >
;;;;;;;;;;;;;;;;Fuel-instrumented function name
(declare-fun Test.esubst__1385 (Fuel Term Term) Term)
;;;;;;;;;;;;;;;;Token for fuel-instrumented partial applications
(declare-fun Test.esubst__1386 () Term)
(declare-fun Exp_abs_1387 (Term Fuel) Term)
;;;;;;;;;;;;;;;;Fuel-instrumented function name
(declare-fun Test.sub_elam__1383 (Fuel Term) Term)
;;;;;;;;;;;;;;;;Token for fuel-instrumented partial applications
(declare-fun Test.sub_elam__1384 () Term)
;;;;;;;;;;;;;;;;Exp_abs_1387 typing
(assert (forall ((@x0 Term) (@u1 Fuel))
 (! (HasType (Exp_abs_1387 @x0
@u1)
Typ_fun_1302)
  
:pattern ((Exp_abs_1387 @x0
@u1)))))
;;;;;;;;;;;;;;;;Exp_abs_1387 interpretation
(assert (forall ((@x0 Term) (@x1 Term) (@u2 Fuel))
 (! (implies (IsTyped (ApplyEE (Exp_abs_1387 @x1
@u2)
@x0))
(= (ApplyEE (Exp_abs_1387 @x1
@u2)
@x0)
(ite (= (Prims.op_Equality Prims.int
@x0
(BoxInt 0))
(BoxBool true))
(Test.EVar (BoxInt 0))
(ite (= (Prims.op_Equality Prims.int
@x0
(BoxInt 0))
(BoxBool false))
(Test.esubst__1385 @u2
Test.sub_einc@tok
(ApplyEE @x1
(Prims.op_Subtraction @x0
(BoxInt 1))))
Term_unit))))
  
:pattern ((ApplyEE (Exp_abs_1387 @x1
@u2)
@x0)))))
;;;;;;;;;;;;;;;;Fuel token correspondence
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (= (ApplyEE (ApplyEF Test.sub_elam__1384
@u0)
@x1)
(Test.sub_elam__1383 @u0
@x1))
  
:pattern ((ApplyEE (ApplyEF Test.sub_elam__1384
@u0)
@x1)))))
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Test.sub@tok)
(HasType (Test.sub_elam__1383 @u0
@x1)
(Typ_refine_1305 @x1)))
  
:pattern ((Test.sub_elam__1383 @u0
@x1)))))
;;;;;;;;;;;;;;;;Correspondence of recursive function to instrumented version
(assert (forall ((@x0 Term))
 (! (= (Test.sub_elam @x0)
(Test.sub_elam__1383 MaxFuel
@x0))
  
:pattern ((Test.sub_elam @x0)))))
;;;;;;;;;;;;;;;;Fuel irrelevance
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (= (Test.sub_elam__1383 (SFuel @u0)
@x1)
(Test.sub_elam__1383 @u0
@x1))
  
:pattern ((Test.sub_elam__1383 (SFuel @u0)
@x1)))))
;;;;;;;;;;;;;;;;Equation for fuel-instrumented recursive function: Test.sub_elam
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Test.sub@tok)
(= (Test.sub_elam__1383 (SFuel @u0)
@x1)
(Exp_abs_1387 @x1
@u0)))
  
:pattern ((Test.sub_elam__1383 (SFuel @u0)
@x1)))))
;;;;;;;;;;;;;;;;Fuel token correspondence
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (= (ApplyEE (ApplyEE (ApplyEF Test.esubst__1386
@u0)
@x1)
@x2)
(Test.esubst__1385 @u0
@x1
@x2))
  
:pattern ((ApplyEE (ApplyEE (ApplyEF Test.esubst__1386
@u0)
@x1)
@x2)))))
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Test.sub@tok)
(HasType @x2
Test.exp))
(HasType (Test.esubst__1385 @u0
@x1
@x2)
(Typ_refine_1289 @x2
@x1)))
  
:pattern ((Test.esubst__1385 @u0
@x1
@x2)))))
;;;;;;;;;;;;;;;;Correspondence of recursive function to instrumented version
(assert (forall ((@x0 Term) (@x1 Term))
 (! (= (Test.esubst @x0
@x1)
(Test.esubst__1385 MaxFuel
@x0
@x1))
  
:pattern ((Test.esubst @x0
@x1)))))
;;;;;;;;;;;;;;;;Fuel irrelevance
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (= (Test.esubst__1385 (SFuel @u0)
@x1
@x2)
(Test.esubst__1385 @u0
@x1
@x2))
  
:pattern ((Test.esubst__1385 (SFuel @u0)
@x1
@x2)))))
;;;;;;;;;;;;;;;;Equation for fuel-instrumented recursive function: Test.esubst
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (implies (and (HasType @x1
Test.sub@tok)
(HasType @x2
Test.exp))
(= (Test.esubst__1385 (SFuel @u0)
@x1
@x2)
(ite (is-Test.EVar @x2)
(ApplyEE @x1
(Test.EVar__0 @x2))
(ite (is-Test.EApp @x2)
(Test.EApp (Test.esubst__1385 @u0
@x1
(Test.EApp__0 @x2))
(Test.esubst__1385 @u0
@x1
(Test.EApp__1 @x2)))
(ite (is-Test.ELam @x2)
(Test.ELam (Test.esubst__1385 @u0
(Test.sub_elam__1383 @u0
@x1)
(Test.ELam__0 @x2)))
Term_unit)))))
  
:pattern ((Test.esubst__1385 (SFuel @u0)
@x1
@x2)))))

; </end encoding >
(push)

; Starting query at bug281.fst(45,0-45,28)
(declare-fun label_1396 () Bool)
(declare-fun Typ_refine_1391 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1391 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1391 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar e)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1391 @x2))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x3))))))
(Valid (Prims.b2t (Test.is_EVar @x2))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1391 @x2))))))
;;;;;;;;;;;;;;;;(e:exp -> Tot r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar e)) ==> (is_EVar r))} (decreases %[(is_evar e); (is_renaming sub_einc); 1; e]))
(declare-fun Typ_fun_1393 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1393 kinding
(assert (HasKind Typ_fun_1393
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1393)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1393)))))
;;;;;;;;;;;;;;;;Typ_fun_1393 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1393)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.exp)
(HasType (ApplyEE @x1
@x2)
(Typ_refine_1391 @x2)))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1393)))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (or label_1396
(forall ((@x0 Term))
 (implies (and (HasType @x0
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x0
(BoxInt 0)))))))))
(check-sat)
(echo "label_1396")
(eval label_1396)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(45,0-45,28)

; encoding sigelt let Test.eesh : (e:exp -> Tot r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar e)) ==> (is_EVar r))} (decreases %[(is_evar e); (is_renaming sub_einc); 1; e]))

; <Start encoding Test.eesh>
(declare-fun Test.eesh (Term) Term)
(declare-fun Typ_refine_1398 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1398 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1398 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar e)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1398 @x2))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x3))))))
(Valid (Prims.b2t (Test.is_EVar @x2))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1398 @x2))))))
;;;;;;;;;;;;;;;;(e:exp -> Tot r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar e)) ==> (is_EVar r))} (decreases %[(is_evar e); (is_renaming sub_einc); 1; e]))
(declare-fun Typ_fun_1400 () Type)
;;;;;;;;;;;;;;;;Typ_fun_1400 kinding
(assert (HasKind Typ_fun_1400
Kind_type))
;;;;;;;;;;;;;;;;pre-typing for functions
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (implies (HasType @x1
Typ_fun_1400)
(is-Typ_fun (PreType @x1)))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1400)))))
;;;;;;;;;;;;;;;;Typ_fun_1400 interpretation
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_fun_1400)
(forall ((@x2 Term))
 (! (implies (HasType @x2
Test.exp)
(HasType (ApplyEE @x1
@x2)
(Typ_refine_1398 @x2)))
  
:pattern ((ApplyEE @x1
@x2)))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_fun_1400)))))
(declare-fun Test.eesh@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1403
(Term_constr_id Test.eesh@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.eesh@tok
@x0)
(Test.eesh @x0))
  
:pattern ((ApplyEE Test.eesh@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.eesh@tok
Typ_fun_1400))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(HasType (Test.eesh @x0)
(Typ_refine_1398 @x0)))
  
:pattern ((Test.eesh @x0)))))
;;;;;;;;;;;;;;;;Equation for Test.eesh
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(= (Test.eesh @x0)
(Test.esubst Test.sub_einc@tok
@x0)))
  
:pattern ((Test.eesh @x0)))))

; </end encoding Test.eesh>
(push)

; Starting query at bug281.fst(47,0-47,81)
;;;;;;;;;;;;;;;;f : exp (exp)
(declare-fun f___2_30 () Term)
(assert (HasType f___2_30
Test.exp))
(declare-fun label_1412 () Bool)
(declare-fun label_1411 () Bool)
(declare-fun label_1410 () Bool)
(declare-fun Typ_refine_1404 () Type)
(assert (HasKind Typ_refine_1404
Kind_type))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar f)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1404)
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x2))))))
(Valid (Prims.b2t (Test.is_EVar f___2_30))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1404)))))
(declare-fun Typ_refine_1406 () Type)
(assert (HasKind Typ_refine_1406
Kind_type))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar (eesh f))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1406)
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x2))))))
(Valid (Prims.b2t (Test.is_EVar (Test.eesh f___2_30)))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1406)))))
(declare-fun Typ_refine_1408 () Type)
(assert (HasKind Typ_refine_1408
Kind_type))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar (eesh (eesh f)))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1408)
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x2))))))
(Valid (Prims.b2t (Test.is_EVar (Test.eesh (Test.eesh f___2_30))))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1408)))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@x0 Term))
 (implies (and (HasType @x0
Typ_refine_1404)
(= @x0
(Test.eesh f___2_30)))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Typ_refine_1406)
(= @x1
(Test.eesh (Test.eesh f___2_30))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
Typ_refine_1408)
(= @x2
(Test.eesh (Test.eesh (Test.eesh f___2_30)))))
(and (or label_1412
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 2)
(BoxInt 0)))))
(forall ((@x3 Term))
 (implies (and (HasType @x3
Test.exp)
(= @x3
(Test.EVar (BoxInt 2))))
(forall ((@x4 Term))
 (implies (and (HasType @x4
Test.exp)
(= @x4
(Test.EApp (Test.eesh (Test.eesh (Test.eesh f___2_30)))
(Test.EVar (BoxInt 2)))))
(and (or label_1411
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 1)
(BoxInt 0)))))
(forall ((@x5 Term))
 (implies (and (HasType @x5
Test.exp)
(= @x5
(Test.EVar (BoxInt 1))))
(forall ((@x6 Term))
 (implies (and (HasType @x6
Test.exp)
(= @x6
(Test.EApp (Test.EApp (Test.eesh (Test.eesh (Test.eesh f___2_30)))
(Test.EVar (BoxInt 2)))
(Test.EVar (BoxInt 1)))))
(or label_1410
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual (BoxInt 0)
(BoxInt 0)))))))))))))))))))))))
(check-sat)
(echo "label_1412")
(eval label_1412)
(echo "label_1411")
(eval label_1411)
(echo "label_1410")
(eval label_1410)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(47,0-47,81)

; encoding sigelt let Test.test : (f:exp -> Tot exp)

; <Start encoding Test.test>
(declare-fun Test.test (Term) Term)
(declare-fun Test.test@tok () Term)
;;;;;;;;;;;;;;;;fresh token
(assert (= 1414
(Term_constr_id Test.test@tok)))
(assert (forall ((@x0 Term))
 (! (= (ApplyEE Test.test@tok
@x0)
(Test.test @x0))
  
:pattern ((ApplyEE Test.test@tok
@x0)))))
;;;;;;;;;;;;;;;;function token typing
(assert (HasType Test.test@tok
Typ_fun_1218))
;;;;;;;;;;;;;;;;free var typing
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(HasType (Test.test @x0)
Test.exp))
  
:pattern ((Test.test @x0)))))
;;;;;;;;;;;;;;;;Equation for Test.test
(assert (forall ((@x0 Term))
 (! (implies (HasType @x0
Test.exp)
(= (Test.test @x0)
(Test.EApp (Test.EApp (Test.EApp (Test.eesh (Test.eesh (Test.eesh @x0)))
(Test.EVar (BoxInt 2)))
(Test.EVar (BoxInt 1)))
(Test.EVar (BoxInt 0)))))
  
:pattern ((Test.test @x0)))))

; </end encoding Test.test>
(push)

; Starting query at bug281.fst(47,81-50,55)
(declare-fun label_1420 () Bool)
(declare-fun Typ_refine_1416 (Term Term) Type)
(assert (forall ((@x0 Term) (@x1 Term))
 (! (HasKind (Typ_refine_1416 @x0
@x1)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1416 @x0
@x1)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_elam s x))) /\ (is_EVar (eesh e))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasType @x1
(Typ_refine_1416 @x2
@x3))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x4 Term))
 (implies (HasType @x4
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE (ApplyEE Test.sub_elam@tok
@x3)
@x4))))))
(Valid (Prims.b2t (Test.is_EVar (Test.eesh @x2)))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1416 @x2
@x3))))))
(declare-fun Typ_refine_1418 (Term Term) Type)
(assert (forall ((@x0 Term) (@x1 Term))
 (! (HasKind (Typ_refine_1418 @x0
@x1)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1418 @x0
@x1)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar (esubst s e))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasType @x1
(Typ_refine_1418 @x2
@x3))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x4 Term))
 (implies (HasType @x4
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x4))))))
(Valid (Prims.b2t (Test.is_EVar (Test.esubst @x3
@x2)))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1418 @x2
@x3))))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@x0 Term) (@x1 Term))
 (implies (and (HasType @x0
Typ_fun_1302)
(HasType @x1
Test.exp))
(or label_1420
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))))))
(check-sat)
(echo "label_1420")
(eval label_1420)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(47,81-50,55)

; encoding sigelt Test.lemma

; <Start encoding Test.lemma>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Test.lemma (Term Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Test.lemma@tok () Term)

; </end encoding Test.lemma>
(push)

; Starting query at bug281.fst(51,0-51,23)
(pop)

; Ending query at bug281.fst(51,0-51,23)

; encoding sigelt let Test.lemma : (s:sub -> e:exp -> Lemma (unit))

; <Skipped Test.lemma/>
(push)

; Starting query at bug281.fst(51,23-64,80)
(declare-fun label_1433 () Bool)
(declare-fun label_1432 () Bool)
(declare-fun label_1431 () Bool)
(declare-fun Typ_refine_1424 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1424 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1424 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:(i:int{(i >= 0)} -> Tot exp){((forall (x). (is_EVar (sub_elam s x))) ==> (forall (x). (is_EVar (r x))))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1424 @x2))
(and (HasType @x1
Typ_fun_1302)
(implies (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE (ApplyEE Test.sub_elam@tok
@x2)
@x3))))))
(forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x1
@x3)))))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1424 @x2))))))
(declare-fun Typ_refine_1427 (Term) Type)
(assert (forall ((@x0 Term))
 (! (HasKind (Typ_refine_1427 @x0)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1427 @x0)
Kind_type)))))
;;;;;;;;;;;;;;;;r:(i:int{(i >= 0)} -> Tot exp){((forall (x). (is_EVar (sub_elam (sub_elam s) x))) ==> (forall (x). (is_EVar (r x))))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term))
 (! (iff (HasType @x1
(Typ_refine_1427 @x2))
(and (HasType @x1
Typ_fun_1302)
(implies (forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE (ApplyEE Test.sub_elam@tok
(Test.sub_elam @x2))
@x3))))))
(forall ((@x3 Term))
 (implies (HasType @x3
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x1
@x3)))))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1427 @x2))))))
(declare-fun Typ_refine_1429 (Term Term) Type)
(assert (forall ((@x0 Term) (@x1 Term))
 (! (HasKind (Typ_refine_1429 @x0
@x1)
Kind_type)
  
:pattern ((HasKind (Typ_refine_1429 @x0
@x1)
Kind_type)))))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_elam (sub_elam (sub_elam s)) x))) /\ (is_EVar (test f))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term) (@x2 Term) (@x3 Term))
 (! (iff (HasType @x1
(Typ_refine_1429 @x2
@x3))
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x4 Term))
 (implies (HasType @x4
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE (ApplyEE Test.sub_elam@tok
(Test.sub_elam (Test.sub_elam @x3)))
@x4))))))
(Valid (Prims.b2t (Test.is_EVar (Test.test @x2)))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
(Typ_refine_1429 @x2
@x3))))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@x0 Term) (@x1 Term))
 (implies (and (HasType @x0
Typ_fun_1302)
(HasType @x1
Test.exp))
(and (or label_1433
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
(Typ_refine_1424 @x0))
(= @x2
(Test.sub_elam (Test.sub_elam @x0))))
(and (or label_1432
(forall ((@x3 Term))
 (implies (and (HasType @x3
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x3
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x3
(BoxInt 0)))))))
(forall ((@x3 Term))
 (implies (and (HasType @x3
(Typ_refine_1427 @x0))
(= @x3
(Test.sub_elam (Test.sub_elam (Test.sub_elam @x0)))))
(or label_1431
(forall ((@x4 Term))
 (implies (and (HasType @x4
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x4
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x4
(BoxInt 0)))))))))))))))))
(check-sat)
(echo "label_1433")
(eval label_1433)
(echo "label_1432")
(eval label_1432)
(echo "label_1431")
(eval label_1431)
(echo "Done!")
(pop)
(pop)

; Ending query at bug281.fst(51,23-64,80)

; encoding sigelt Test.plouf2

; <Start encoding Test.plouf2>
;;;;;;;;;;;;;;;;Uninterpreted function symbol for impure function
(declare-fun Test.plouf2 (Term Term) Term)
;;;;;;;;;;;;;;;;Uninterpreted name for impure function
(declare-fun Test.plouf2@tok () Term)

; </end encoding Test.plouf2>
(push)

; Starting query at bug281.fst(65,0-67,29)
;;;;;;;;;;;;;;;;s : sub ((i:int{(i >= 0)} -> Tot exp))
(declare-fun s___2_37 () Term)
(assert (HasType s___2_37
Typ_fun_1302))
;;;;;;;;;;;;;;;;f : exp (exp)
(declare-fun f___2_38 () Term)
(assert (HasType f___2_38
Test.exp))
(declare-fun label_1444 () Bool)
(declare-fun label_1443 () Bool)
(declare-fun label_1442 () Bool)
(declare-fun Typ_refine_1436 () Type)
(assert (HasKind Typ_refine_1436
Kind_type))
;;;;;;;;;;;;;;;;r:(i:int{(i >= 0)} -> Tot exp){((forall (x). (is_EVar (sub_elam s x))) ==> (forall (x). (is_EVar (r x))))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1436)
(and (HasType @x1
Typ_fun_1302)
(implies (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE (ApplyEE Test.sub_elam@tok
s___2_37)
@x2))))))
(forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (ApplyEE @x1
@x2)))))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1436)))))
(declare-fun Typ_refine_1438 () Type)
(assert (HasKind Typ_refine_1438
Kind_type))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar f)) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1438)
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x2))))))
(Valid (Prims.b2t (Test.is_EVar f___2_38))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1438)))))
(declare-fun Typ_refine_1440 () Type)
(assert (HasKind Typ_refine_1440
Kind_type))
;;;;;;;;;;;;;;;;r:exp{(((forall (x). (is_EVar (sub_einc x))) /\ (is_EVar (eesh f))) ==> (is_EVar r))}
(assert (forall ((@u0 Fuel) (@x1 Term))
 (! (iff (HasType @x1
Typ_refine_1440)
(and (HasType @x1
Test.exp)
(implies (and (forall ((@x2 Term))
 (implies (HasType @x2
Typ_refine_1144)
(Valid (Prims.b2t (Test.is_EVar (Test.sub_einc @x2))))))
(Valid (Prims.b2t (Test.is_EVar (Test.eesh f___2_38)))))
(Valid (Prims.b2t (Test.is_EVar @x1))))))
  
:pattern ((HasTypeFuel @u0
@x1
Typ_refine_1440)))))
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel ZFuel))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@a0 Type))
 (implies (and (forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.unit)
(HasKind (ApplyTE @a0
@x1)
Kind_type))
  
:pattern ((ApplyTE @a0
@x1))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.test f___2_38))
(Test.test (Test.esubst s___2_37
f___2_38))))))
(Valid (ApplyTE @a0
@x1)))))
(and (or label_1444
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Typ_refine_1436)
(= @x1
(Test.sub_elam (Test.sub_elam s___2_37))))
(and (or label_1443
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
Typ_refine_1438)
(= @x2
(Test.eesh f___2_38)))
(forall ((@x3 Term))
 (implies (and (HasType @x3
Typ_refine_1440)
(= @x3
(Test.eesh (Test.eesh f___2_38))))
(forall ((@x4 Term))
 (implies (and (HasType @x4
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.eesh (Test.eesh (Test.eesh f___2_38))))
(Test.eesh (Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))))
(= @x4
(Test.lemma (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))
(and (or label_1442
(forall ((@x5 Term))
 (implies (and (HasType @x5
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))))
(forall ((@x5 Term))
 (implies (and (HasType @x5
Typ_refine_1438)
(= @x5
(Test.eesh f___2_38)))
(forall ((@x6 Term))
 (implies (and (HasType @x6
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))
(Test.eesh (Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))))
(= @x6
(Test.lemma (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))
(forall ((@x7 Term))
 (implies (and (HasType @x7
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))
(Test.eesh (Test.esubst s___2_37
f___2_38)))))
(= @x7
(Test.lemma s___2_37
f___2_38)))
(Valid (ApplyTE @a0
@x7)))))))))))))))))))))))
(check-sat)
(echo "label_1444")
(eval label_1444)
(echo "label_1443")
(eval label_1443)
(echo "label_1442")
(eval label_1442)
(echo "Done!")
(pop)
(push)

; <fuel='4'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel ZFuel))))))
(assert (= MaxIFuel
(SFuel (SFuel (SFuel (SFuel (SFuel (SFuel ZFuel))))))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@a0 Type))
 (implies (and (forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.unit)
(HasKind (ApplyTE @a0
@x1)
Kind_type))
  
:pattern ((ApplyTE @a0
@x1))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.test f___2_38))
(Test.test (Test.esubst s___2_37
f___2_38))))))
(Valid (ApplyTE @a0
@x1)))))
(and (or label_1444
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Typ_refine_1436)
(= @x1
(Test.sub_elam (Test.sub_elam s___2_37))))
(and (or label_1443
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
Typ_refine_1438)
(= @x2
(Test.eesh f___2_38)))
(forall ((@x3 Term))
 (implies (and (HasType @x3
Typ_refine_1440)
(= @x3
(Test.eesh (Test.eesh f___2_38))))
(forall ((@x4 Term))
 (implies (and (HasType @x4
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.eesh (Test.eesh (Test.eesh f___2_38))))
(Test.eesh (Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))))
(= @x4
(Test.lemma (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))
(and (or label_1442
(forall ((@x5 Term))
 (implies (and (HasType @x5
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))))
(forall ((@x5 Term))
 (implies (and (HasType @x5
Typ_refine_1438)
(= @x5
(Test.eesh f___2_38)))
(forall ((@x6 Term))
 (implies (and (HasType @x6
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))
(Test.eesh (Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))))
(= @x6
(Test.lemma (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))
(forall ((@x7 Term))
 (implies (and (HasType @x7
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))
(Test.eesh (Test.esubst s___2_37
f___2_38)))))
(= @x7
(Test.lemma s___2_37
f___2_38)))
(Valid (ApplyTE @a0
@x7)))))))))))))))))))))))
(check-sat)
(echo "label_1444")
(eval label_1444)
(echo "label_1443")
(eval label_1443)
(echo "label_1442")
(eval label_1442)
(echo "Done!")
(pop)
(push)

; <fuel='8'>
(assert (= MaxFuel
(SFuel (SFuel (SFuel (SFuel (SFuel (SFuel (SFuel (SFuel ZFuel))))))))))
(assert (= MaxIFuel
(SFuel (SFuel (SFuel (SFuel (SFuel (SFuel ZFuel))))))))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@a0 Type))
 (implies (and (forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.unit)
(HasKind (ApplyTE @a0
@x1)
Kind_type))
  
:pattern ((ApplyTE @a0
@x1))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.test f___2_38))
(Test.test (Test.esubst s___2_37
f___2_38))))))
(Valid (ApplyTE @a0
@x1)))))
(and (or label_1444
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Typ_refine_1436)
(= @x1
(Test.sub_elam (Test.sub_elam s___2_37))))
(and (or label_1443
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
Typ_refine_1438)
(= @x2
(Test.eesh f___2_38)))
(forall ((@x3 Term))
 (implies (and (HasType @x3
Typ_refine_1440)
(= @x3
(Test.eesh (Test.eesh f___2_38))))
(forall ((@x4 Term))
 (implies (and (HasType @x4
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.eesh (Test.eesh (Test.eesh f___2_38))))
(Test.eesh (Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))))
(= @x4
(Test.lemma (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))
(and (or label_1442
(forall ((@x5 Term))
 (implies (and (HasType @x5
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))))
(forall ((@x5 Term))
 (implies (and (HasType @x5
Typ_refine_1438)
(= @x5
(Test.eesh f___2_38)))
(forall ((@x6 Term))
 (implies (and (HasType @x6
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))
(Test.eesh (Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))))
(= @x6
(Test.lemma (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))
(forall ((@x7 Term))
 (implies (and (HasType @x7
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))
(Test.eesh (Test.esubst s___2_37
f___2_38)))))
(= @x7
(Test.lemma s___2_37
f___2_38)))
(Valid (ApplyTE @a0
@x7)))))))))))))))))))))))
(check-sat)
(echo "label_1444")
(eval label_1444)
(echo "label_1443")
(eval label_1443)
(echo "label_1442")
(eval label_1442)
(echo "Done!")
(pop)
(push)

; <fuel='1'>
(assert (= MaxFuel
(SFuel ZFuel)))
(assert (= MaxIFuel
(SFuel ZFuel)))
;;;;;;;;;;;;;;;;query
(assert (not (forall ((@a0 Type))
 (implies (and (forall ((@x1 Term))
 (! (implies (HasType @x1
Prims.unit)
(HasKind (ApplyTE @a0
@x1)
Kind_type))
  
:pattern ((ApplyTE @a0
@x1))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.test f___2_38))
(Test.test (Test.esubst s___2_37
f___2_38))))))
(Valid (ApplyTE @a0
@x1)))))
(and (or label_1444
(forall ((@x1 Term))
 (implies (and (HasType @x1
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x1
(BoxInt 0)))))))
(forall ((@x1 Term))
 (implies (and (HasType @x1
Typ_refine_1436)
(= @x1
(Test.sub_elam (Test.sub_elam s___2_37))))
(and (or label_1443
(forall ((@x2 Term))
 (implies (and (HasType @x2
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x2
(BoxInt 0)))))))
(forall ((@x2 Term))
 (implies (and (HasType @x2
Typ_refine_1438)
(= @x2
(Test.eesh f___2_38)))
(forall ((@x3 Term))
 (implies (and (HasType @x3
Typ_refine_1440)
(= @x3
(Test.eesh (Test.eesh f___2_38))))
(forall ((@x4 Term))
 (implies (and (HasType @x4
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam (Test.sub_elam s___2_37)))
(Test.eesh (Test.eesh (Test.eesh f___2_38))))
(Test.eesh (Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))))
(= @x4
(Test.lemma (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))))
(and (or label_1442
(forall ((@x5 Term))
 (implies (and (HasType @x5
Prims.int)
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))
(Valid (Prims.b2t (Prims.op_GreaterThanOrEqual @x5
(BoxInt 0)))))))
(forall ((@x5 Term))
 (implies (and (HasType @x5
Typ_refine_1438)
(= @x5
(Test.eesh f___2_38)))
(forall ((@x6 Term))
 (implies (and (HasType @x6
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam (Test.sub_elam s___2_37))
(Test.eesh (Test.eesh f___2_38)))
(Test.eesh (Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))))
(= @x6
(Test.lemma (Test.sub_elam s___2_37)
(Test.eesh f___2_38))))
(forall ((@x7 Term))
 (implies (and (HasType @x7
Prims.unit)
(Valid (Prims.b2t (Prims.op_Equality Test.exp
(Test.esubst (Test.sub_elam s___2_37)
(Test.eesh f___2_38))
(Test.eesh (Test.esubst s___2_37
f___2_38)))))
(= @x7
(Test.lemma s___2_37
f___2_38)))
(Valid (ApplyTE @a0
@x7)))))))))))))))))))))))
(check-sat)
(echo "label_1444")
(eval label_1444)
(echo "label_1443")
(eval label_1443)
(echo "label_1442")
(eval label_1442)
(echo "Done!")
(pop)