text:
Ty : Type
Ty = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty : Ty
empty = \ _, empty, _ => empty

arr : Ty -> Ty -> Ty
arr = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con : Type
Con = (Con : Type)
 ->(nil  : Con)
 ->(snoc : Con -> Ty -> Con)
 -> Con

nil : Con
nil = \ con, nil, snoc => nil

snoc : Con -> Ty -> Con
snoc = \ g, a, con, nil, snoc => snoc (g con nil snoc) a

Var : Con -> Ty -> Type
Var = \ g, a =>
    (Var : Con -> Ty -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var (snoc g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var g a -> Var (snoc g b) a)
 -> Var g a

vz : {g : _}-> {a : _} -> Var (snoc g a) a
vz = \ var, vz, vs => vz _ _

vs : {g : _} -> {B : _} -> {a : _} -> Var g a -> Var (snoc g B) a
vs = \ x, var, vz, vs => vs _ _ _ (x var vz vs)

Tm : Con -> Ty -> Type
Tm = \ g, a =>
    (Tm    : Con -> Ty -> Type)
 -> (var   : (g : _) -> (a : _) -> Var g a -> Tm g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm (snoc g a) B -> Tm g (arr a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm g (arr a B) -> Tm g a -> Tm g B)
 -> Tm g a

var : {g : _} -> {a : _} -> Var g a -> Tm g a
var = \ x, tm, var, lam, app => var _ _ x

lam : {g : _} -> {a : _} -> {B : _} -> Tm (snoc g a) B -> Tm g (arr a B)
lam = \ t, tm, var, lam, app => lam _ _ _ (t tm var lam app)

app : {g:_}->{a:_}->{B:_} -> Tm g (arr a B) -> Tm g a -> Tm g B
app = \ t, u, tm, var, lam, app => app _ _ _ (t tm var lam app) (u tm var lam app)

v0 : {g:_}->{a:_} -> Tm (snoc g a) a
v0 = var vz

v1 : {g:_}->{a:_}-> {B:_}-> Tm (snoc (snoc g a) B) a
v1 = var (vs vz)

v2 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm (snoc (snoc (snoc g a) B) C) a
v2 = var (vs (vs vz))

v3 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm (snoc (snoc (snoc (snoc g a) B) C) D) a
v3 = var (vs (vs (vs vz)))

v4 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm (snoc (snoc (snoc (snoc (snoc g a) B) C) D) E) a
v4 = var (vs (vs (vs (vs vz))))

test : {g:_}-> {a:_} -> Tm g (arr (arr a a) (arr a a))
test  = lam (lam (app v1 (app v1 (app v1 (app v1 (app v1 (app v1 v0)))))))
Ty1 : Type
Ty1 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty1 : Ty1
empty1 = \ _, empty, _ => empty

arr1 : Ty1 -> Ty1 -> Ty1
arr1 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con1 : Type
Con1 = (Con1 : Type)
 ->(nil  : Con1)
 ->(snoc : Con1 -> Ty1 -> Con1)
 -> Con1

nil1 : Con1
nil1 = \ con, nil1, snoc => nil1

snoc1 : Con1 -> Ty1 -> Con1
snoc1 = \ g, a, con, nil1, snoc1 => snoc1 (g con nil1 snoc1) a

Var1 : Con1 -> Ty1 -> Type
Var1 = \ g, a =>
    (Var1 : Con1 -> Ty1 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var1 (snoc1 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var1 g a -> Var1 (snoc1 g b) a)
 -> Var1 g a

vz1 : {g : _}-> {a : _} -> Var1 (snoc1 g a) a
vz1 = \ var, vz1, vs => vz1 _ _

vs1 : {g : _} -> {B : _} -> {a : _} -> Var1 g a -> Var1 (snoc1 g B) a
vs1 = \ x, var, vz1, vs1 => vs1 _ _ _ (x var vz1 vs1)

Tm1 : Con1 -> Ty1 -> Type
Tm1 = \ g, a =>
    (Tm1    : Con1 -> Ty1 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var1 g a -> Tm1 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm1 (snoc1 g a) B -> Tm1 g (arr1 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm1 g (arr1 a B) -> Tm1 g a -> Tm1 g B)
 -> Tm1 g a

var1 : {g : _} -> {a : _} -> Var1 g a -> Tm1 g a
var1 = \ x, tm, var1, lam, app => var1 _ _ x

lam1 : {g : _} -> {a : _} -> {B : _} -> Tm1 (snoc1 g a) B -> Tm1 g (arr1 a B)
lam1 = \ t, tm, var1, lam1, app => lam1 _ _ _ (t tm var1 lam1 app)

app1 : {g:_}->{a:_}->{B:_} -> Tm1 g (arr1 a B) -> Tm1 g a -> Tm1 g B
app1 = \ t, u, tm, var1, lam1, app1 => app1 _ _ _ (t tm var1 lam1 app1) (u tm var1 lam1 app1)

v01 : {g:_}->{a:_} -> Tm1 (snoc1 g a) a
v01 = var1 vz1

v11 : {g:_}->{a:_}-> {B:_}-> Tm1 (snoc1 (snoc1 g a) B) a
v11 = var1 (vs1 vz1)

v21 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm1 (snoc1 (snoc1 (snoc1 g a) B) C) a
v21 = var1 (vs1 (vs1 vz1))

v31 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm1 (snoc1 (snoc1 (snoc1 (snoc1 g a) B) C) D) a
v31 = var1 (vs1 (vs1 (vs1 vz1)))

v41 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm1 (snoc1 (snoc1 (snoc1 (snoc1 (snoc1 g a) B) C) D) E) a
v41 = var1 (vs1 (vs1 (vs1 (vs1 vz1))))

test1 : {g:_}-> {a:_} -> Tm1 g (arr1 (arr1 a a) (arr1 a a))
test1  = lam1 (lam1 (app1 v11 (app1 v11 (app1 v11 (app1 v11 (app1 v11 (app1 v11 v01)))))))
Ty2 : Type
Ty2 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty2 : Ty2
empty2 = \ _, empty, _ => empty

arr2 : Ty2 -> Ty2 -> Ty2
arr2 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con2 : Type
Con2 = (Con2 : Type)
 ->(nil  : Con2)
 ->(snoc : Con2 -> Ty2 -> Con2)
 -> Con2

nil2 : Con2
nil2 = \ con, nil2, snoc => nil2

snoc2 : Con2 -> Ty2 -> Con2
snoc2 = \ g, a, con, nil2, snoc2 => snoc2 (g con nil2 snoc2) a

Var2 : Con2 -> Ty2 -> Type
Var2 = \ g, a =>
    (Var2 : Con2 -> Ty2 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var2 (snoc2 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var2 g a -> Var2 (snoc2 g b) a)
 -> Var2 g a

vz2 : {g : _}-> {a : _} -> Var2 (snoc2 g a) a
vz2 = \ var, vz2, vs => vz2 _ _

vs2 : {g : _} -> {B : _} -> {a : _} -> Var2 g a -> Var2 (snoc2 g B) a
vs2 = \ x, var, vz2, vs2 => vs2 _ _ _ (x var vz2 vs2)

Tm2 : Con2 -> Ty2 -> Type
Tm2 = \ g, a =>
    (Tm2    : Con2 -> Ty2 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var2 g a -> Tm2 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm2 (snoc2 g a) B -> Tm2 g (arr2 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm2 g (arr2 a B) -> Tm2 g a -> Tm2 g B)
 -> Tm2 g a

var2 : {g : _} -> {a : _} -> Var2 g a -> Tm2 g a
var2 = \ x, tm, var2, lam, app => var2 _ _ x

lam2 : {g : _} -> {a : _} -> {B : _} -> Tm2 (snoc2 g a) B -> Tm2 g (arr2 a B)
lam2 = \ t, tm, var2, lam2, app => lam2 _ _ _ (t tm var2 lam2 app)

app2 : {g:_}->{a:_}->{B:_} -> Tm2 g (arr2 a B) -> Tm2 g a -> Tm2 g B
app2 = \ t, u, tm, var2, lam2, app2 => app2 _ _ _ (t tm var2 lam2 app2) (u tm var2 lam2 app2)

v02 : {g:_}->{a:_} -> Tm2 (snoc2 g a) a
v02 = var2 vz2

v12 : {g:_}->{a:_}-> {B:_}-> Tm2 (snoc2 (snoc2 g a) B) a
v12 = var2 (vs2 vz2)

v22 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm2 (snoc2 (snoc2 (snoc2 g a) B) C) a
v22 = var2 (vs2 (vs2 vz2))

v32 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm2 (snoc2 (snoc2 (snoc2 (snoc2 g a) B) C) D) a
v32 = var2 (vs2 (vs2 (vs2 vz2)))

v42 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm2 (snoc2 (snoc2 (snoc2 (snoc2 (snoc2 g a) B) C) D) E) a
v42 = var2 (vs2 (vs2 (vs2 (vs2 vz2))))

test2 : {g:_}-> {a:_} -> Tm2 g (arr2 (arr2 a a) (arr2 a a))
test2  = lam2 (lam2 (app2 v12 (app2 v12 (app2 v12 (app2 v12 (app2 v12 (app2 v12 v02)))))))
Ty3 : Type
Ty3 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty3 : Ty3
empty3 = \ _, empty, _ => empty

arr3 : Ty3 -> Ty3 -> Ty3
arr3 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con3 : Type
Con3 = (Con3 : Type)
 ->(nil  : Con3)
 ->(snoc : Con3 -> Ty3 -> Con3)
 -> Con3

nil3 : Con3
nil3 = \ con, nil3, snoc => nil3

snoc3 : Con3 -> Ty3 -> Con3
snoc3 = \ g, a, con, nil3, snoc3 => snoc3 (g con nil3 snoc3) a

Var3 : Con3 -> Ty3 -> Type
Var3 = \ g, a =>
    (Var3 : Con3 -> Ty3 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var3 (snoc3 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var3 g a -> Var3 (snoc3 g b) a)
 -> Var3 g a

vz3 : {g : _}-> {a : _} -> Var3 (snoc3 g a) a
vz3 = \ var, vz3, vs => vz3 _ _

vs3 : {g : _} -> {B : _} -> {a : _} -> Var3 g a -> Var3 (snoc3 g B) a
vs3 = \ x, var, vz3, vs3 => vs3 _ _ _ (x var vz3 vs3)

Tm3 : Con3 -> Ty3 -> Type
Tm3 = \ g, a =>
    (Tm3    : Con3 -> Ty3 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var3 g a -> Tm3 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm3 (snoc3 g a) B -> Tm3 g (arr3 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm3 g (arr3 a B) -> Tm3 g a -> Tm3 g B)
 -> Tm3 g a

var3 : {g : _} -> {a : _} -> Var3 g a -> Tm3 g a
var3 = \ x, tm, var3, lam, app => var3 _ _ x

lam3 : {g : _} -> {a : _} -> {B : _} -> Tm3 (snoc3 g a) B -> Tm3 g (arr3 a B)
lam3 = \ t, tm, var3, lam3, app => lam3 _ _ _ (t tm var3 lam3 app)

app3 : {g:_}->{a:_}->{B:_} -> Tm3 g (arr3 a B) -> Tm3 g a -> Tm3 g B
app3 = \ t, u, tm, var3, lam3, app3 => app3 _ _ _ (t tm var3 lam3 app3) (u tm var3 lam3 app3)

v03 : {g:_}->{a:_} -> Tm3 (snoc3 g a) a
v03 = var3 vz3

v13 : {g:_}->{a:_}-> {B:_}-> Tm3 (snoc3 (snoc3 g a) B) a
v13 = var3 (vs3 vz3)

v23 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm3 (snoc3 (snoc3 (snoc3 g a) B) C) a
v23 = var3 (vs3 (vs3 vz3))

v33 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm3 (snoc3 (snoc3 (snoc3 (snoc3 g a) B) C) D) a
v33 = var3 (vs3 (vs3 (vs3 vz3)))

v43 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm3 (snoc3 (snoc3 (snoc3 (snoc3 (snoc3 g a) B) C) D) E) a
v43 = var3 (vs3 (vs3 (vs3 (vs3 vz3))))

test3 : {g:_}-> {a:_} -> Tm3 g (arr3 (arr3 a a) (arr3 a a))
test3  = lam3 (lam3 (app3 v13 (app3 v13 (app3 v13 (app3 v13 (app3 v13 (app3 v13 v03)))))))
Ty4 : Type
Ty4 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty4 : Ty4
empty4 = \ _, empty, _ => empty

arr4 : Ty4 -> Ty4 -> Ty4
arr4 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con4 : Type
Con4 = (Con4 : Type)
 ->(nil  : Con4)
 ->(snoc : Con4 -> Ty4 -> Con4)
 -> Con4

nil4 : Con4
nil4 = \ con, nil4, snoc => nil4

snoc4 : Con4 -> Ty4 -> Con4
snoc4 = \ g, a, con, nil4, snoc4 => snoc4 (g con nil4 snoc4) a

Var4 : Con4 -> Ty4 -> Type
Var4 = \ g, a =>
    (Var4 : Con4 -> Ty4 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var4 (snoc4 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var4 g a -> Var4 (snoc4 g b) a)
 -> Var4 g a

vz4 : {g : _}-> {a : _} -> Var4 (snoc4 g a) a
vz4 = \ var, vz4, vs => vz4 _ _

vs4 : {g : _} -> {B : _} -> {a : _} -> Var4 g a -> Var4 (snoc4 g B) a
vs4 = \ x, var, vz4, vs4 => vs4 _ _ _ (x var vz4 vs4)

Tm4 : Con4 -> Ty4 -> Type
Tm4 = \ g, a =>
    (Tm4    : Con4 -> Ty4 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var4 g a -> Tm4 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm4 (snoc4 g a) B -> Tm4 g (arr4 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm4 g (arr4 a B) -> Tm4 g a -> Tm4 g B)
 -> Tm4 g a

var4 : {g : _} -> {a : _} -> Var4 g a -> Tm4 g a
var4 = \ x, tm, var4, lam, app => var4 _ _ x

lam4 : {g : _} -> {a : _} -> {B : _} -> Tm4 (snoc4 g a) B -> Tm4 g (arr4 a B)
lam4 = \ t, tm, var4, lam4, app => lam4 _ _ _ (t tm var4 lam4 app)

app4 : {g:_}->{a:_}->{B:_} -> Tm4 g (arr4 a B) -> Tm4 g a -> Tm4 g B
app4 = \ t, u, tm, var4, lam4, app4 => app4 _ _ _ (t tm var4 lam4 app4) (u tm var4 lam4 app4)

v04 : {g:_}->{a:_} -> Tm4 (snoc4 g a) a
v04 = var4 vz4

v14 : {g:_}->{a:_}-> {B:_}-> Tm4 (snoc4 (snoc4 g a) B) a
v14 = var4 (vs4 vz4)

v24 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm4 (snoc4 (snoc4 (snoc4 g a) B) C) a
v24 = var4 (vs4 (vs4 vz4))

v34 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm4 (snoc4 (snoc4 (snoc4 (snoc4 g a) B) C) D) a
v34 = var4 (vs4 (vs4 (vs4 vz4)))

v44 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm4 (snoc4 (snoc4 (snoc4 (snoc4 (snoc4 g a) B) C) D) E) a
v44 = var4 (vs4 (vs4 (vs4 (vs4 vz4))))

test4 : {g:_}-> {a:_} -> Tm4 g (arr4 (arr4 a a) (arr4 a a))
test4  = lam4 (lam4 (app4 v14 (app4 v14 (app4 v14 (app4 v14 (app4 v14 (app4 v14 v04)))))))
Ty5 : Type
Ty5 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty5 : Ty5
empty5 = \ _, empty, _ => empty

arr5 : Ty5 -> Ty5 -> Ty5
arr5 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con5 : Type
Con5 = (Con5 : Type)
 ->(nil  : Con5)
 ->(snoc : Con5 -> Ty5 -> Con5)
 -> Con5

nil5 : Con5
nil5 = \ con, nil5, snoc => nil5

snoc5 : Con5 -> Ty5 -> Con5
snoc5 = \ g, a, con, nil5, snoc5 => snoc5 (g con nil5 snoc5) a

Var5 : Con5 -> Ty5 -> Type
Var5 = \ g, a =>
    (Var5 : Con5 -> Ty5 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var5 (snoc5 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var5 g a -> Var5 (snoc5 g b) a)
 -> Var5 g a

vz5 : {g : _}-> {a : _} -> Var5 (snoc5 g a) a
vz5 = \ var, vz5, vs => vz5 _ _

vs5 : {g : _} -> {B : _} -> {a : _} -> Var5 g a -> Var5 (snoc5 g B) a
vs5 = \ x, var, vz5, vs5 => vs5 _ _ _ (x var vz5 vs5)

Tm5 : Con5 -> Ty5 -> Type
Tm5 = \ g, a =>
    (Tm5    : Con5 -> Ty5 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var5 g a -> Tm5 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm5 (snoc5 g a) B -> Tm5 g (arr5 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm5 g (arr5 a B) -> Tm5 g a -> Tm5 g B)
 -> Tm5 g a

var5 : {g : _} -> {a : _} -> Var5 g a -> Tm5 g a
var5 = \ x, tm, var5, lam, app => var5 _ _ x

lam5 : {g : _} -> {a : _} -> {B : _} -> Tm5 (snoc5 g a) B -> Tm5 g (arr5 a B)
lam5 = \ t, tm, var5, lam5, app => lam5 _ _ _ (t tm var5 lam5 app)

app5 : {g:_}->{a:_}->{B:_} -> Tm5 g (arr5 a B) -> Tm5 g a -> Tm5 g B
app5 = \ t, u, tm, var5, lam5, app5 => app5 _ _ _ (t tm var5 lam5 app5) (u tm var5 lam5 app5)

v05 : {g:_}->{a:_} -> Tm5 (snoc5 g a) a
v05 = var5 vz5

v15 : {g:_}->{a:_}-> {B:_}-> Tm5 (snoc5 (snoc5 g a) B) a
v15 = var5 (vs5 vz5)

v25 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm5 (snoc5 (snoc5 (snoc5 g a) B) C) a
v25 = var5 (vs5 (vs5 vz5))

v35 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm5 (snoc5 (snoc5 (snoc5 (snoc5 g a) B) C) D) a
v35 = var5 (vs5 (vs5 (vs5 vz5)))

v45 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm5 (snoc5 (snoc5 (snoc5 (snoc5 (snoc5 g a) B) C) D) E) a
v45 = var5 (vs5 (vs5 (vs5 (vs5 vz5))))

test5 : {g:_}-> {a:_} -> Tm5 g (arr5 (arr5 a a) (arr5 a a))
test5  = lam5 (lam5 (app5 v15 (app5 v15 (app5 v15 (app5 v15 (app5 v15 (app5 v15 v05)))))))
Ty6 : Type
Ty6 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty6 : Ty6
empty6 = \ _, empty, _ => empty

arr6 : Ty6 -> Ty6 -> Ty6
arr6 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con6 : Type
Con6 = (Con6 : Type)
 ->(nil  : Con6)
 ->(snoc : Con6 -> Ty6 -> Con6)
 -> Con6

nil6 : Con6
nil6 = \ con, nil6, snoc => nil6

snoc6 : Con6 -> Ty6 -> Con6
snoc6 = \ g, a, con, nil6, snoc6 => snoc6 (g con nil6 snoc6) a

Var6 : Con6 -> Ty6 -> Type
Var6 = \ g, a =>
    (Var6 : Con6 -> Ty6 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var6 (snoc6 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var6 g a -> Var6 (snoc6 g b) a)
 -> Var6 g a

vz6 : {g : _}-> {a : _} -> Var6 (snoc6 g a) a
vz6 = \ var, vz6, vs => vz6 _ _

vs6 : {g : _} -> {B : _} -> {a : _} -> Var6 g a -> Var6 (snoc6 g B) a
vs6 = \ x, var, vz6, vs6 => vs6 _ _ _ (x var vz6 vs6)

Tm6 : Con6 -> Ty6 -> Type
Tm6 = \ g, a =>
    (Tm6    : Con6 -> Ty6 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var6 g a -> Tm6 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm6 (snoc6 g a) B -> Tm6 g (arr6 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm6 g (arr6 a B) -> Tm6 g a -> Tm6 g B)
 -> Tm6 g a

var6 : {g : _} -> {a : _} -> Var6 g a -> Tm6 g a
var6 = \ x, tm, var6, lam, app => var6 _ _ x

lam6 : {g : _} -> {a : _} -> {B : _} -> Tm6 (snoc6 g a) B -> Tm6 g (arr6 a B)
lam6 = \ t, tm, var6, lam6, app => lam6 _ _ _ (t tm var6 lam6 app)

app6 : {g:_}->{a:_}->{B:_} -> Tm6 g (arr6 a B) -> Tm6 g a -> Tm6 g B
app6 = \ t, u, tm, var6, lam6, app6 => app6 _ _ _ (t tm var6 lam6 app6) (u tm var6 lam6 app6)

v06 : {g:_}->{a:_} -> Tm6 (snoc6 g a) a
v06 = var6 vz6

v16 : {g:_}->{a:_}-> {B:_}-> Tm6 (snoc6 (snoc6 g a) B) a
v16 = var6 (vs6 vz6)

v26 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm6 (snoc6 (snoc6 (snoc6 g a) B) C) a
v26 = var6 (vs6 (vs6 vz6))

v36 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm6 (snoc6 (snoc6 (snoc6 (snoc6 g a) B) C) D) a
v36 = var6 (vs6 (vs6 (vs6 vz6)))

v46 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm6 (snoc6 (snoc6 (snoc6 (snoc6 (snoc6 g a) B) C) D) E) a
v46 = var6 (vs6 (vs6 (vs6 (vs6 vz6))))

test6 : {g:_}-> {a:_} -> Tm6 g (arr6 (arr6 a a) (arr6 a a))
test6  = lam6 (lam6 (app6 v16 (app6 v16 (app6 v16 (app6 v16 (app6 v16 (app6 v16 v06)))))))
Ty7 : Type
Ty7 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty7 : Ty7
empty7 = \ _, empty, _ => empty

arr7 : Ty7 -> Ty7 -> Ty7
arr7 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con7 : Type
Con7 = (Con7 : Type)
 ->(nil  : Con7)
 ->(snoc : Con7 -> Ty7 -> Con7)
 -> Con7

nil7 : Con7
nil7 = \ con, nil7, snoc => nil7

snoc7 : Con7 -> Ty7 -> Con7
snoc7 = \ g, a, con, nil7, snoc7 => snoc7 (g con nil7 snoc7) a

Var7 : Con7 -> Ty7 -> Type
Var7 = \ g, a =>
    (Var7 : Con7 -> Ty7 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var7 (snoc7 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var7 g a -> Var7 (snoc7 g b) a)
 -> Var7 g a

vz7 : {g : _}-> {a : _} -> Var7 (snoc7 g a) a
vz7 = \ var, vz7, vs => vz7 _ _

vs7 : {g : _} -> {B : _} -> {a : _} -> Var7 g a -> Var7 (snoc7 g B) a
vs7 = \ x, var, vz7, vs7 => vs7 _ _ _ (x var vz7 vs7)

Tm7 : Con7 -> Ty7 -> Type
Tm7 = \ g, a =>
    (Tm7    : Con7 -> Ty7 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var7 g a -> Tm7 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm7 (snoc7 g a) B -> Tm7 g (arr7 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm7 g (arr7 a B) -> Tm7 g a -> Tm7 g B)
 -> Tm7 g a

var7 : {g : _} -> {a : _} -> Var7 g a -> Tm7 g a
var7 = \ x, tm, var7, lam, app => var7 _ _ x

lam7 : {g : _} -> {a : _} -> {B : _} -> Tm7 (snoc7 g a) B -> Tm7 g (arr7 a B)
lam7 = \ t, tm, var7, lam7, app => lam7 _ _ _ (t tm var7 lam7 app)

app7 : {g:_}->{a:_}->{B:_} -> Tm7 g (arr7 a B) -> Tm7 g a -> Tm7 g B
app7 = \ t, u, tm, var7, lam7, app7 => app7 _ _ _ (t tm var7 lam7 app7) (u tm var7 lam7 app7)

v07 : {g:_}->{a:_} -> Tm7 (snoc7 g a) a
v07 = var7 vz7

v17 : {g:_}->{a:_}-> {B:_}-> Tm7 (snoc7 (snoc7 g a) B) a
v17 = var7 (vs7 vz7)

v27 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm7 (snoc7 (snoc7 (snoc7 g a) B) C) a
v27 = var7 (vs7 (vs7 vz7))

v37 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm7 (snoc7 (snoc7 (snoc7 (snoc7 g a) B) C) D) a
v37 = var7 (vs7 (vs7 (vs7 vz7)))

v47 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm7 (snoc7 (snoc7 (snoc7 (snoc7 (snoc7 g a) B) C) D) E) a
v47 = var7 (vs7 (vs7 (vs7 (vs7 vz7))))

test7 : {g:_}-> {a:_} -> Tm7 g (arr7 (arr7 a a) (arr7 a a))
test7  = lam7 (lam7 (app7 v17 (app7 v17 (app7 v17 (app7 v17 (app7 v17 (app7 v17 v07)))))))
Ty8 : Type
Ty8 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty8 : Ty8
empty8 = \ _, empty, _ => empty

arr8 : Ty8 -> Ty8 -> Ty8
arr8 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con8 : Type
Con8 = (Con8 : Type)
 ->(nil  : Con8)
 ->(snoc : Con8 -> Ty8 -> Con8)
 -> Con8

nil8 : Con8
nil8 = \ con, nil8, snoc => nil8

snoc8 : Con8 -> Ty8 -> Con8
snoc8 = \ g, a, con, nil8, snoc8 => snoc8 (g con nil8 snoc8) a

Var8 : Con8 -> Ty8 -> Type
Var8 = \ g, a =>
    (Var8 : Con8 -> Ty8 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var8 (snoc8 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var8 g a -> Var8 (snoc8 g b) a)
 -> Var8 g a

vz8 : {g : _}-> {a : _} -> Var8 (snoc8 g a) a
vz8 = \ var, vz8, vs => vz8 _ _

vs8 : {g : _} -> {B : _} -> {a : _} -> Var8 g a -> Var8 (snoc8 g B) a
vs8 = \ x, var, vz8, vs8 => vs8 _ _ _ (x var vz8 vs8)

Tm8 : Con8 -> Ty8 -> Type
Tm8 = \ g, a =>
    (Tm8    : Con8 -> Ty8 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var8 g a -> Tm8 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm8 (snoc8 g a) B -> Tm8 g (arr8 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm8 g (arr8 a B) -> Tm8 g a -> Tm8 g B)
 -> Tm8 g a

var8 : {g : _} -> {a : _} -> Var8 g a -> Tm8 g a
var8 = \ x, tm, var8, lam, app => var8 _ _ x

lam8 : {g : _} -> {a : _} -> {B : _} -> Tm8 (snoc8 g a) B -> Tm8 g (arr8 a B)
lam8 = \ t, tm, var8, lam8, app => lam8 _ _ _ (t tm var8 lam8 app)

app8 : {g:_}->{a:_}->{B:_} -> Tm8 g (arr8 a B) -> Tm8 g a -> Tm8 g B
app8 = \ t, u, tm, var8, lam8, app8 => app8 _ _ _ (t tm var8 lam8 app8) (u tm var8 lam8 app8)

v08 : {g:_}->{a:_} -> Tm8 (snoc8 g a) a
v08 = var8 vz8

v18 : {g:_}->{a:_}-> {B:_}-> Tm8 (snoc8 (snoc8 g a) B) a
v18 = var8 (vs8 vz8)

v28 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm8 (snoc8 (snoc8 (snoc8 g a) B) C) a
v28 = var8 (vs8 (vs8 vz8))

v38 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm8 (snoc8 (snoc8 (snoc8 (snoc8 g a) B) C) D) a
v38 = var8 (vs8 (vs8 (vs8 vz8)))

v48 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm8 (snoc8 (snoc8 (snoc8 (snoc8 (snoc8 g a) B) C) D) E) a
v48 = var8 (vs8 (vs8 (vs8 (vs8 vz8))))

test8 : {g:_}-> {a:_} -> Tm8 g (arr8 (arr8 a a) (arr8 a a))
test8  = lam8 (lam8 (app8 v18 (app8 v18 (app8 v18 (app8 v18 (app8 v18 (app8 v18 v08)))))))
Ty9 : Type
Ty9 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty9 : Ty9
empty9 = \ _, empty, _ => empty

arr9 : Ty9 -> Ty9 -> Ty9
arr9 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con9 : Type
Con9 = (Con9 : Type)
 ->(nil  : Con9)
 ->(snoc : Con9 -> Ty9 -> Con9)
 -> Con9

nil9 : Con9
nil9 = \ con, nil9, snoc => nil9

snoc9 : Con9 -> Ty9 -> Con9
snoc9 = \ g, a, con, nil9, snoc9 => snoc9 (g con nil9 snoc9) a

Var9 : Con9 -> Ty9 -> Type
Var9 = \ g, a =>
    (Var9 : Con9 -> Ty9 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var9 (snoc9 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var9 g a -> Var9 (snoc9 g b) a)
 -> Var9 g a

vz9 : {g : _}-> {a : _} -> Var9 (snoc9 g a) a
vz9 = \ var, vz9, vs => vz9 _ _

vs9 : {g : _} -> {B : _} -> {a : _} -> Var9 g a -> Var9 (snoc9 g B) a
vs9 = \ x, var, vz9, vs9 => vs9 _ _ _ (x var vz9 vs9)

Tm9 : Con9 -> Ty9 -> Type
Tm9 = \ g, a =>
    (Tm9    : Con9 -> Ty9 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var9 g a -> Tm9 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm9 (snoc9 g a) B -> Tm9 g (arr9 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm9 g (arr9 a B) -> Tm9 g a -> Tm9 g B)
 -> Tm9 g a

var9 : {g : _} -> {a : _} -> Var9 g a -> Tm9 g a
var9 = \ x, tm, var9, lam, app => var9 _ _ x

lam9 : {g : _} -> {a : _} -> {B : _} -> Tm9 (snoc9 g a) B -> Tm9 g (arr9 a B)
lam9 = \ t, tm, var9, lam9, app => lam9 _ _ _ (t tm var9 lam9 app)

app9 : {g:_}->{a:_}->{B:_} -> Tm9 g (arr9 a B) -> Tm9 g a -> Tm9 g B
app9 = \ t, u, tm, var9, lam9, app9 => app9 _ _ _ (t tm var9 lam9 app9) (u tm var9 lam9 app9)

v09 : {g:_}->{a:_} -> Tm9 (snoc9 g a) a
v09 = var9 vz9

v19 : {g:_}->{a:_}-> {B:_}-> Tm9 (snoc9 (snoc9 g a) B) a
v19 = var9 (vs9 vz9)

v29 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm9 (snoc9 (snoc9 (snoc9 g a) B) C) a
v29 = var9 (vs9 (vs9 vz9))

v39 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm9 (snoc9 (snoc9 (snoc9 (snoc9 g a) B) C) D) a
v39 = var9 (vs9 (vs9 (vs9 vz9)))

v49 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm9 (snoc9 (snoc9 (snoc9 (snoc9 (snoc9 g a) B) C) D) E) a
v49 = var9 (vs9 (vs9 (vs9 (vs9 vz9))))

test9 : {g:_}-> {a:_} -> Tm9 g (arr9 (arr9 a a) (arr9 a a))
test9  = lam9 (lam9 (app9 v19 (app9 v19 (app9 v19 (app9 v19 (app9 v19 (app9 v19 v09)))))))
Ty10 : Type
Ty10 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty10 : Ty10
empty10 = \ _, empty, _ => empty

arr10 : Ty10 -> Ty10 -> Ty10
arr10 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con10 : Type
Con10 = (Con10 : Type)
 ->(nil  : Con10)
 ->(snoc : Con10 -> Ty10 -> Con10)
 -> Con10

nil10 : Con10
nil10 = \ con, nil10, snoc => nil10

snoc10 : Con10 -> Ty10 -> Con10
snoc10 = \ g, a, con, nil10, snoc10 => snoc10 (g con nil10 snoc10) a

Var10 : Con10 -> Ty10 -> Type
Var10 = \ g, a =>
    (Var10 : Con10 -> Ty10 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var10 (snoc10 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var10 g a -> Var10 (snoc10 g b) a)
 -> Var10 g a

vz10 : {g : _}-> {a : _} -> Var10 (snoc10 g a) a
vz10 = \ var, vz10, vs => vz10 _ _

vs10 : {g : _} -> {B : _} -> {a : _} -> Var10 g a -> Var10 (snoc10 g B) a
vs10 = \ x, var, vz10, vs10 => vs10 _ _ _ (x var vz10 vs10)

Tm10 : Con10 -> Ty10 -> Type
Tm10 = \ g, a =>
    (Tm10    : Con10 -> Ty10 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var10 g a -> Tm10 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm10 (snoc10 g a) B -> Tm10 g (arr10 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm10 g (arr10 a B) -> Tm10 g a -> Tm10 g B)
 -> Tm10 g a

var10 : {g : _} -> {a : _} -> Var10 g a -> Tm10 g a
var10 = \ x, tm, var10, lam, app => var10 _ _ x

lam10 : {g : _} -> {a : _} -> {B : _} -> Tm10 (snoc10 g a) B -> Tm10 g (arr10 a B)
lam10 = \ t, tm, var10, lam10, app => lam10 _ _ _ (t tm var10 lam10 app)

app10 : {g:_}->{a:_}->{B:_} -> Tm10 g (arr10 a B) -> Tm10 g a -> Tm10 g B
app10 = \ t, u, tm, var10, lam10, app10 => app10 _ _ _ (t tm var10 lam10 app10) (u tm var10 lam10 app10)

v010 : {g:_}->{a:_} -> Tm10 (snoc10 g a) a
v010 = var10 vz10

v110 : {g:_}->{a:_}-> {B:_}-> Tm10 (snoc10 (snoc10 g a) B) a
v110 = var10 (vs10 vz10)

v210 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm10 (snoc10 (snoc10 (snoc10 g a) B) C) a
v210 = var10 (vs10 (vs10 vz10))

v310 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm10 (snoc10 (snoc10 (snoc10 (snoc10 g a) B) C) D) a
v310 = var10 (vs10 (vs10 (vs10 vz10)))

v410 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm10 (snoc10 (snoc10 (snoc10 (snoc10 (snoc10 g a) B) C) D) E) a
v410 = var10 (vs10 (vs10 (vs10 (vs10 vz10))))

test10 : {g:_}-> {a:_} -> Tm10 g (arr10 (arr10 a a) (arr10 a a))
test10  = lam10 (lam10 (app10 v110 (app10 v110 (app10 v110 (app10 v110 (app10 v110 (app10 v110 v010)))))))
Ty11 : Type
Ty11 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty11 : Ty11
empty11 = \ _, empty, _ => empty

arr11 : Ty11 -> Ty11 -> Ty11
arr11 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con11 : Type
Con11 = (Con11 : Type)
 ->(nil  : Con11)
 ->(snoc : Con11 -> Ty11 -> Con11)
 -> Con11

nil11 : Con11
nil11 = \ con, nil11, snoc => nil11

snoc11 : Con11 -> Ty11 -> Con11
snoc11 = \ g, a, con, nil11, snoc11 => snoc11 (g con nil11 snoc11) a

Var11 : Con11 -> Ty11 -> Type
Var11 = \ g, a =>
    (Var11 : Con11 -> Ty11 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var11 (snoc11 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var11 g a -> Var11 (snoc11 g b) a)
 -> Var11 g a

vz11 : {g : _}-> {a : _} -> Var11 (snoc11 g a) a
vz11 = \ var, vz11, vs => vz11 _ _

vs11 : {g : _} -> {B : _} -> {a : _} -> Var11 g a -> Var11 (snoc11 g B) a
vs11 = \ x, var, vz11, vs11 => vs11 _ _ _ (x var vz11 vs11)

Tm11 : Con11 -> Ty11 -> Type
Tm11 = \ g, a =>
    (Tm11    : Con11 -> Ty11 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var11 g a -> Tm11 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm11 (snoc11 g a) B -> Tm11 g (arr11 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm11 g (arr11 a B) -> Tm11 g a -> Tm11 g B)
 -> Tm11 g a

var11 : {g : _} -> {a : _} -> Var11 g a -> Tm11 g a
var11 = \ x, tm, var11, lam, app => var11 _ _ x

lam11 : {g : _} -> {a : _} -> {B : _} -> Tm11 (snoc11 g a) B -> Tm11 g (arr11 a B)
lam11 = \ t, tm, var11, lam11, app => lam11 _ _ _ (t tm var11 lam11 app)

app11 : {g:_}->{a:_}->{B:_} -> Tm11 g (arr11 a B) -> Tm11 g a -> Tm11 g B
app11 = \ t, u, tm, var11, lam11, app11 => app11 _ _ _ (t tm var11 lam11 app11) (u tm var11 lam11 app11)

v011 : {g:_}->{a:_} -> Tm11 (snoc11 g a) a
v011 = var11 vz11

v111 : {g:_}->{a:_}-> {B:_}-> Tm11 (snoc11 (snoc11 g a) B) a
v111 = var11 (vs11 vz11)

v211 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm11 (snoc11 (snoc11 (snoc11 g a) B) C) a
v211 = var11 (vs11 (vs11 vz11))

v311 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm11 (snoc11 (snoc11 (snoc11 (snoc11 g a) B) C) D) a
v311 = var11 (vs11 (vs11 (vs11 vz11)))

v411 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm11 (snoc11 (snoc11 (snoc11 (snoc11 (snoc11 g a) B) C) D) E) a
v411 = var11 (vs11 (vs11 (vs11 (vs11 vz11))))

test11 : {g:_}-> {a:_} -> Tm11 g (arr11 (arr11 a a) (arr11 a a))
test11  = lam11 (lam11 (app11 v111 (app11 v111 (app11 v111 (app11 v111 (app11 v111 (app11 v111 v011)))))))
Ty12 : Type
Ty12 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty12 : Ty12
empty12 = \ _, empty, _ => empty

arr12 : Ty12 -> Ty12 -> Ty12
arr12 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con12 : Type
Con12 = (Con12 : Type)
 ->(nil  : Con12)
 ->(snoc : Con12 -> Ty12 -> Con12)
 -> Con12

nil12 : Con12
nil12 = \ con, nil12, snoc => nil12

snoc12 : Con12 -> Ty12 -> Con12
snoc12 = \ g, a, con, nil12, snoc12 => snoc12 (g con nil12 snoc12) a

Var12 : Con12 -> Ty12 -> Type
Var12 = \ g, a =>
    (Var12 : Con12 -> Ty12 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var12 (snoc12 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var12 g a -> Var12 (snoc12 g b) a)
 -> Var12 g a

vz12 : {g : _}-> {a : _} -> Var12 (snoc12 g a) a
vz12 = \ var, vz12, vs => vz12 _ _

vs12 : {g : _} -> {B : _} -> {a : _} -> Var12 g a -> Var12 (snoc12 g B) a
vs12 = \ x, var, vz12, vs12 => vs12 _ _ _ (x var vz12 vs12)

Tm12 : Con12 -> Ty12 -> Type
Tm12 = \ g, a =>
    (Tm12    : Con12 -> Ty12 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var12 g a -> Tm12 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm12 (snoc12 g a) B -> Tm12 g (arr12 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm12 g (arr12 a B) -> Tm12 g a -> Tm12 g B)
 -> Tm12 g a

var12 : {g : _} -> {a : _} -> Var12 g a -> Tm12 g a
var12 = \ x, tm, var12, lam, app => var12 _ _ x

lam12 : {g : _} -> {a : _} -> {B : _} -> Tm12 (snoc12 g a) B -> Tm12 g (arr12 a B)
lam12 = \ t, tm, var12, lam12, app => lam12 _ _ _ (t tm var12 lam12 app)

app12 : {g:_}->{a:_}->{B:_} -> Tm12 g (arr12 a B) -> Tm12 g a -> Tm12 g B
app12 = \ t, u, tm, var12, lam12, app12 => app12 _ _ _ (t tm var12 lam12 app12) (u tm var12 lam12 app12)

v012 : {g:_}->{a:_} -> Tm12 (snoc12 g a) a
v012 = var12 vz12

v112 : {g:_}->{a:_}-> {B:_}-> Tm12 (snoc12 (snoc12 g a) B) a
v112 = var12 (vs12 vz12)

v212 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm12 (snoc12 (snoc12 (snoc12 g a) B) C) a
v212 = var12 (vs12 (vs12 vz12))

v312 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm12 (snoc12 (snoc12 (snoc12 (snoc12 g a) B) C) D) a
v312 = var12 (vs12 (vs12 (vs12 vz12)))

v412 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm12 (snoc12 (snoc12 (snoc12 (snoc12 (snoc12 g a) B) C) D) E) a
v412 = var12 (vs12 (vs12 (vs12 (vs12 vz12))))

test12 : {g:_}-> {a:_} -> Tm12 g (arr12 (arr12 a a) (arr12 a a))
test12  = lam12 (lam12 (app12 v112 (app12 v112 (app12 v112 (app12 v112 (app12 v112 (app12 v112 v012)))))))
Ty13 : Type
Ty13 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty13 : Ty13
empty13 = \ _, empty, _ => empty

arr13 : Ty13 -> Ty13 -> Ty13
arr13 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con13 : Type
Con13 = (Con13 : Type)
 ->(nil  : Con13)
 ->(snoc : Con13 -> Ty13 -> Con13)
 -> Con13

nil13 : Con13
nil13 = \ con, nil13, snoc => nil13

snoc13 : Con13 -> Ty13 -> Con13
snoc13 = \ g, a, con, nil13, snoc13 => snoc13 (g con nil13 snoc13) a

Var13 : Con13 -> Ty13 -> Type
Var13 = \ g, a =>
    (Var13 : Con13 -> Ty13 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var13 (snoc13 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var13 g a -> Var13 (snoc13 g b) a)
 -> Var13 g a

vz13 : {g : _}-> {a : _} -> Var13 (snoc13 g a) a
vz13 = \ var, vz13, vs => vz13 _ _

vs13 : {g : _} -> {B : _} -> {a : _} -> Var13 g a -> Var13 (snoc13 g B) a
vs13 = \ x, var, vz13, vs13 => vs13 _ _ _ (x var vz13 vs13)

Tm13 : Con13 -> Ty13 -> Type
Tm13 = \ g, a =>
    (Tm13    : Con13 -> Ty13 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var13 g a -> Tm13 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm13 (snoc13 g a) B -> Tm13 g (arr13 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm13 g (arr13 a B) -> Tm13 g a -> Tm13 g B)
 -> Tm13 g a

var13 : {g : _} -> {a : _} -> Var13 g a -> Tm13 g a
var13 = \ x, tm, var13, lam, app => var13 _ _ x

lam13 : {g : _} -> {a : _} -> {B : _} -> Tm13 (snoc13 g a) B -> Tm13 g (arr13 a B)
lam13 = \ t, tm, var13, lam13, app => lam13 _ _ _ (t tm var13 lam13 app)

app13 : {g:_}->{a:_}->{B:_} -> Tm13 g (arr13 a B) -> Tm13 g a -> Tm13 g B
app13 = \ t, u, tm, var13, lam13, app13 => app13 _ _ _ (t tm var13 lam13 app13) (u tm var13 lam13 app13)

v013 : {g:_}->{a:_} -> Tm13 (snoc13 g a) a
v013 = var13 vz13

v113 : {g:_}->{a:_}-> {B:_}-> Tm13 (snoc13 (snoc13 g a) B) a
v113 = var13 (vs13 vz13)

v213 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm13 (snoc13 (snoc13 (snoc13 g a) B) C) a
v213 = var13 (vs13 (vs13 vz13))

v313 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm13 (snoc13 (snoc13 (snoc13 (snoc13 g a) B) C) D) a
v313 = var13 (vs13 (vs13 (vs13 vz13)))

v413 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm13 (snoc13 (snoc13 (snoc13 (snoc13 (snoc13 g a) B) C) D) E) a
v413 = var13 (vs13 (vs13 (vs13 (vs13 vz13))))

test13 : {g:_}-> {a:_} -> Tm13 g (arr13 (arr13 a a) (arr13 a a))
test13  = lam13 (lam13 (app13 v113 (app13 v113 (app13 v113 (app13 v113 (app13 v113 (app13 v113 v013)))))))
Ty14 : Type
Ty14 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty14 : Ty14
empty14 = \ _, empty, _ => empty

arr14 : Ty14 -> Ty14 -> Ty14
arr14 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con14 : Type
Con14 = (Con14 : Type)
 ->(nil  : Con14)
 ->(snoc : Con14 -> Ty14 -> Con14)
 -> Con14

nil14 : Con14
nil14 = \ con, nil14, snoc => nil14

snoc14 : Con14 -> Ty14 -> Con14
snoc14 = \ g, a, con, nil14, snoc14 => snoc14 (g con nil14 snoc14) a

Var14 : Con14 -> Ty14 -> Type
Var14 = \ g, a =>
    (Var14 : Con14 -> Ty14 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var14 (snoc14 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var14 g a -> Var14 (snoc14 g b) a)
 -> Var14 g a

vz14 : {g : _}-> {a : _} -> Var14 (snoc14 g a) a
vz14 = \ var, vz14, vs => vz14 _ _

vs14 : {g : _} -> {B : _} -> {a : _} -> Var14 g a -> Var14 (snoc14 g B) a
vs14 = \ x, var, vz14, vs14 => vs14 _ _ _ (x var vz14 vs14)

Tm14 : Con14 -> Ty14 -> Type
Tm14 = \ g, a =>
    (Tm14    : Con14 -> Ty14 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var14 g a -> Tm14 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm14 (snoc14 g a) B -> Tm14 g (arr14 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm14 g (arr14 a B) -> Tm14 g a -> Tm14 g B)
 -> Tm14 g a

var14 : {g : _} -> {a : _} -> Var14 g a -> Tm14 g a
var14 = \ x, tm, var14, lam, app => var14 _ _ x

lam14 : {g : _} -> {a : _} -> {B : _} -> Tm14 (snoc14 g a) B -> Tm14 g (arr14 a B)
lam14 = \ t, tm, var14, lam14, app => lam14 _ _ _ (t tm var14 lam14 app)

app14 : {g:_}->{a:_}->{B:_} -> Tm14 g (arr14 a B) -> Tm14 g a -> Tm14 g B
app14 = \ t, u, tm, var14, lam14, app14 => app14 _ _ _ (t tm var14 lam14 app14) (u tm var14 lam14 app14)

v014 : {g:_}->{a:_} -> Tm14 (snoc14 g a) a
v014 = var14 vz14

v114 : {g:_}->{a:_}-> {B:_}-> Tm14 (snoc14 (snoc14 g a) B) a
v114 = var14 (vs14 vz14)

v214 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm14 (snoc14 (snoc14 (snoc14 g a) B) C) a
v214 = var14 (vs14 (vs14 vz14))

v314 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm14 (snoc14 (snoc14 (snoc14 (snoc14 g a) B) C) D) a
v314 = var14 (vs14 (vs14 (vs14 vz14)))

v414 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm14 (snoc14 (snoc14 (snoc14 (snoc14 (snoc14 g a) B) C) D) E) a
v414 = var14 (vs14 (vs14 (vs14 (vs14 vz14))))

test14 : {g:_}-> {a:_} -> Tm14 g (arr14 (arr14 a a) (arr14 a a))
test14  = lam14 (lam14 (app14 v114 (app14 v114 (app14 v114 (app14 v114 (app14 v114 (app14 v114 v014)))))))
Ty15 : Type
Ty15 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty15 : Ty15
empty15 = \ _, empty, _ => empty

arr15 : Ty15 -> Ty15 -> Ty15
arr15 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con15 : Type
Con15 = (Con15 : Type)
 ->(nil  : Con15)
 ->(snoc : Con15 -> Ty15 -> Con15)
 -> Con15

nil15 : Con15
nil15 = \ con, nil15, snoc => nil15

snoc15 : Con15 -> Ty15 -> Con15
snoc15 = \ g, a, con, nil15, snoc15 => snoc15 (g con nil15 snoc15) a

Var15 : Con15 -> Ty15 -> Type
Var15 = \ g, a =>
    (Var15 : Con15 -> Ty15 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var15 (snoc15 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var15 g a -> Var15 (snoc15 g b) a)
 -> Var15 g a

vz15 : {g : _}-> {a : _} -> Var15 (snoc15 g a) a
vz15 = \ var, vz15, vs => vz15 _ _

vs15 : {g : _} -> {B : _} -> {a : _} -> Var15 g a -> Var15 (snoc15 g B) a
vs15 = \ x, var, vz15, vs15 => vs15 _ _ _ (x var vz15 vs15)

Tm15 : Con15 -> Ty15 -> Type
Tm15 = \ g, a =>
    (Tm15    : Con15 -> Ty15 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var15 g a -> Tm15 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm15 (snoc15 g a) B -> Tm15 g (arr15 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm15 g (arr15 a B) -> Tm15 g a -> Tm15 g B)
 -> Tm15 g a

var15 : {g : _} -> {a : _} -> Var15 g a -> Tm15 g a
var15 = \ x, tm, var15, lam, app => var15 _ _ x

lam15 : {g : _} -> {a : _} -> {B : _} -> Tm15 (snoc15 g a) B -> Tm15 g (arr15 a B)
lam15 = \ t, tm, var15, lam15, app => lam15 _ _ _ (t tm var15 lam15 app)

app15 : {g:_}->{a:_}->{B:_} -> Tm15 g (arr15 a B) -> Tm15 g a -> Tm15 g B
app15 = \ t, u, tm, var15, lam15, app15 => app15 _ _ _ (t tm var15 lam15 app15) (u tm var15 lam15 app15)

v015 : {g:_}->{a:_} -> Tm15 (snoc15 g a) a
v015 = var15 vz15

v115 : {g:_}->{a:_}-> {B:_}-> Tm15 (snoc15 (snoc15 g a) B) a
v115 = var15 (vs15 vz15)

v215 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm15 (snoc15 (snoc15 (snoc15 g a) B) C) a
v215 = var15 (vs15 (vs15 vz15))

v315 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm15 (snoc15 (snoc15 (snoc15 (snoc15 g a) B) C) D) a
v315 = var15 (vs15 (vs15 (vs15 vz15)))

v415 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm15 (snoc15 (snoc15 (snoc15 (snoc15 (snoc15 g a) B) C) D) E) a
v415 = var15 (vs15 (vs15 (vs15 (vs15 vz15))))

test15 : {g:_}-> {a:_} -> Tm15 g (arr15 (arr15 a a) (arr15 a a))
test15  = lam15 (lam15 (app15 v115 (app15 v115 (app15 v115 (app15 v115 (app15 v115 (app15 v115 v015)))))))
Ty16 : Type
Ty16 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty16 : Ty16
empty16 = \ _, empty, _ => empty

arr16 : Ty16 -> Ty16 -> Ty16
arr16 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con16 : Type
Con16 = (Con16 : Type)
 ->(nil  : Con16)
 ->(snoc : Con16 -> Ty16 -> Con16)
 -> Con16

nil16 : Con16
nil16 = \ con, nil16, snoc => nil16

snoc16 : Con16 -> Ty16 -> Con16
snoc16 = \ g, a, con, nil16, snoc16 => snoc16 (g con nil16 snoc16) a

Var16 : Con16 -> Ty16 -> Type
Var16 = \ g, a =>
    (Var16 : Con16 -> Ty16 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var16 (snoc16 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var16 g a -> Var16 (snoc16 g b) a)
 -> Var16 g a

vz16 : {g : _}-> {a : _} -> Var16 (snoc16 g a) a
vz16 = \ var, vz16, vs => vz16 _ _

vs16 : {g : _} -> {B : _} -> {a : _} -> Var16 g a -> Var16 (snoc16 g B) a
vs16 = \ x, var, vz16, vs16 => vs16 _ _ _ (x var vz16 vs16)

Tm16 : Con16 -> Ty16 -> Type
Tm16 = \ g, a =>
    (Tm16    : Con16 -> Ty16 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var16 g a -> Tm16 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm16 (snoc16 g a) B -> Tm16 g (arr16 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm16 g (arr16 a B) -> Tm16 g a -> Tm16 g B)
 -> Tm16 g a

var16 : {g : _} -> {a : _} -> Var16 g a -> Tm16 g a
var16 = \ x, tm, var16, lam, app => var16 _ _ x

lam16 : {g : _} -> {a : _} -> {B : _} -> Tm16 (snoc16 g a) B -> Tm16 g (arr16 a B)
lam16 = \ t, tm, var16, lam16, app => lam16 _ _ _ (t tm var16 lam16 app)

app16 : {g:_}->{a:_}->{B:_} -> Tm16 g (arr16 a B) -> Tm16 g a -> Tm16 g B
app16 = \ t, u, tm, var16, lam16, app16 => app16 _ _ _ (t tm var16 lam16 app16) (u tm var16 lam16 app16)

v016 : {g:_}->{a:_} -> Tm16 (snoc16 g a) a
v016 = var16 vz16

v116 : {g:_}->{a:_}-> {B:_}-> Tm16 (snoc16 (snoc16 g a) B) a
v116 = var16 (vs16 vz16)

v216 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm16 (snoc16 (snoc16 (snoc16 g a) B) C) a
v216 = var16 (vs16 (vs16 vz16))

v316 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm16 (snoc16 (snoc16 (snoc16 (snoc16 g a) B) C) D) a
v316 = var16 (vs16 (vs16 (vs16 vz16)))

v416 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm16 (snoc16 (snoc16 (snoc16 (snoc16 (snoc16 g a) B) C) D) E) a
v416 = var16 (vs16 (vs16 (vs16 (vs16 vz16))))

test16 : {g:_}-> {a:_} -> Tm16 g (arr16 (arr16 a a) (arr16 a a))
test16  = lam16 (lam16 (app16 v116 (app16 v116 (app16 v116 (app16 v116 (app16 v116 (app16 v116 v016)))))))
Ty17 : Type
Ty17 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty17 : Ty17
empty17 = \ _, empty, _ => empty

arr17 : Ty17 -> Ty17 -> Ty17
arr17 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con17 : Type
Con17 = (Con17 : Type)
 ->(nil  : Con17)
 ->(snoc : Con17 -> Ty17 -> Con17)
 -> Con17

nil17 : Con17
nil17 = \ con, nil17, snoc => nil17

snoc17 : Con17 -> Ty17 -> Con17
snoc17 = \ g, a, con, nil17, snoc17 => snoc17 (g con nil17 snoc17) a

Var17 : Con17 -> Ty17 -> Type
Var17 = \ g, a =>
    (Var17 : Con17 -> Ty17 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var17 (snoc17 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var17 g a -> Var17 (snoc17 g b) a)
 -> Var17 g a

vz17 : {g : _}-> {a : _} -> Var17 (snoc17 g a) a
vz17 = \ var, vz17, vs => vz17 _ _

vs17 : {g : _} -> {B : _} -> {a : _} -> Var17 g a -> Var17 (snoc17 g B) a
vs17 = \ x, var, vz17, vs17 => vs17 _ _ _ (x var vz17 vs17)

Tm17 : Con17 -> Ty17 -> Type
Tm17 = \ g, a =>
    (Tm17    : Con17 -> Ty17 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var17 g a -> Tm17 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm17 (snoc17 g a) B -> Tm17 g (arr17 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm17 g (arr17 a B) -> Tm17 g a -> Tm17 g B)
 -> Tm17 g a

var17 : {g : _} -> {a : _} -> Var17 g a -> Tm17 g a
var17 = \ x, tm, var17, lam, app => var17 _ _ x

lam17 : {g : _} -> {a : _} -> {B : _} -> Tm17 (snoc17 g a) B -> Tm17 g (arr17 a B)
lam17 = \ t, tm, var17, lam17, app => lam17 _ _ _ (t tm var17 lam17 app)

app17 : {g:_}->{a:_}->{B:_} -> Tm17 g (arr17 a B) -> Tm17 g a -> Tm17 g B
app17 = \ t, u, tm, var17, lam17, app17 => app17 _ _ _ (t tm var17 lam17 app17) (u tm var17 lam17 app17)

v017 : {g:_}->{a:_} -> Tm17 (snoc17 g a) a
v017 = var17 vz17

v117 : {g:_}->{a:_}-> {B:_}-> Tm17 (snoc17 (snoc17 g a) B) a
v117 = var17 (vs17 vz17)

v217 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm17 (snoc17 (snoc17 (snoc17 g a) B) C) a
v217 = var17 (vs17 (vs17 vz17))

v317 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm17 (snoc17 (snoc17 (snoc17 (snoc17 g a) B) C) D) a
v317 = var17 (vs17 (vs17 (vs17 vz17)))

v417 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm17 (snoc17 (snoc17 (snoc17 (snoc17 (snoc17 g a) B) C) D) E) a
v417 = var17 (vs17 (vs17 (vs17 (vs17 vz17))))

test17 : {g:_}-> {a:_} -> Tm17 g (arr17 (arr17 a a) (arr17 a a))
test17  = lam17 (lam17 (app17 v117 (app17 v117 (app17 v117 (app17 v117 (app17 v117 (app17 v117 v017)))))))
Ty18 : Type
Ty18 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty18 : Ty18
empty18 = \ _, empty, _ => empty

arr18 : Ty18 -> Ty18 -> Ty18
arr18 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con18 : Type
Con18 = (Con18 : Type)
 ->(nil  : Con18)
 ->(snoc : Con18 -> Ty18 -> Con18)
 -> Con18

nil18 : Con18
nil18 = \ con, nil18, snoc => nil18

snoc18 : Con18 -> Ty18 -> Con18
snoc18 = \ g, a, con, nil18, snoc18 => snoc18 (g con nil18 snoc18) a

Var18 : Con18 -> Ty18 -> Type
Var18 = \ g, a =>
    (Var18 : Con18 -> Ty18 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var18 (snoc18 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var18 g a -> Var18 (snoc18 g b) a)
 -> Var18 g a

vz18 : {g : _}-> {a : _} -> Var18 (snoc18 g a) a
vz18 = \ var, vz18, vs => vz18 _ _

vs18 : {g : _} -> {B : _} -> {a : _} -> Var18 g a -> Var18 (snoc18 g B) a
vs18 = \ x, var, vz18, vs18 => vs18 _ _ _ (x var vz18 vs18)

Tm18 : Con18 -> Ty18 -> Type
Tm18 = \ g, a =>
    (Tm18    : Con18 -> Ty18 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var18 g a -> Tm18 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm18 (snoc18 g a) B -> Tm18 g (arr18 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm18 g (arr18 a B) -> Tm18 g a -> Tm18 g B)
 -> Tm18 g a

var18 : {g : _} -> {a : _} -> Var18 g a -> Tm18 g a
var18 = \ x, tm, var18, lam, app => var18 _ _ x

lam18 : {g : _} -> {a : _} -> {B : _} -> Tm18 (snoc18 g a) B -> Tm18 g (arr18 a B)
lam18 = \ t, tm, var18, lam18, app => lam18 _ _ _ (t tm var18 lam18 app)

app18 : {g:_}->{a:_}->{B:_} -> Tm18 g (arr18 a B) -> Tm18 g a -> Tm18 g B
app18 = \ t, u, tm, var18, lam18, app18 => app18 _ _ _ (t tm var18 lam18 app18) (u tm var18 lam18 app18)

v018 : {g:_}->{a:_} -> Tm18 (snoc18 g a) a
v018 = var18 vz18

v118 : {g:_}->{a:_}-> {B:_}-> Tm18 (snoc18 (snoc18 g a) B) a
v118 = var18 (vs18 vz18)

v218 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm18 (snoc18 (snoc18 (snoc18 g a) B) C) a
v218 = var18 (vs18 (vs18 vz18))

v318 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm18 (snoc18 (snoc18 (snoc18 (snoc18 g a) B) C) D) a
v318 = var18 (vs18 (vs18 (vs18 vz18)))

v418 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm18 (snoc18 (snoc18 (snoc18 (snoc18 (snoc18 g a) B) C) D) E) a
v418 = var18 (vs18 (vs18 (vs18 (vs18 vz18))))

test18 : {g:_}-> {a:_} -> Tm18 g (arr18 (arr18 a a) (arr18 a a))
test18  = lam18 (lam18 (app18 v118 (app18 v118 (app18 v118 (app18 v118 (app18 v118 (app18 v118 v018)))))))
Ty19 : Type
Ty19 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty19 : Ty19
empty19 = \ _, empty, _ => empty

arr19 : Ty19 -> Ty19 -> Ty19
arr19 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con19 : Type
Con19 = (Con19 : Type)
 ->(nil  : Con19)
 ->(snoc : Con19 -> Ty19 -> Con19)
 -> Con19

nil19 : Con19
nil19 = \ con, nil19, snoc => nil19

snoc19 : Con19 -> Ty19 -> Con19
snoc19 = \ g, a, con, nil19, snoc19 => snoc19 (g con nil19 snoc19) a

Var19 : Con19 -> Ty19 -> Type
Var19 = \ g, a =>
    (Var19 : Con19 -> Ty19 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var19 (snoc19 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var19 g a -> Var19 (snoc19 g b) a)
 -> Var19 g a

vz19 : {g : _}-> {a : _} -> Var19 (snoc19 g a) a
vz19 = \ var, vz19, vs => vz19 _ _

vs19 : {g : _} -> {B : _} -> {a : _} -> Var19 g a -> Var19 (snoc19 g B) a
vs19 = \ x, var, vz19, vs19 => vs19 _ _ _ (x var vz19 vs19)

Tm19 : Con19 -> Ty19 -> Type
Tm19 = \ g, a =>
    (Tm19    : Con19 -> Ty19 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var19 g a -> Tm19 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm19 (snoc19 g a) B -> Tm19 g (arr19 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm19 g (arr19 a B) -> Tm19 g a -> Tm19 g B)
 -> Tm19 g a

var19 : {g : _} -> {a : _} -> Var19 g a -> Tm19 g a
var19 = \ x, tm, var19, lam, app => var19 _ _ x

lam19 : {g : _} -> {a : _} -> {B : _} -> Tm19 (snoc19 g a) B -> Tm19 g (arr19 a B)
lam19 = \ t, tm, var19, lam19, app => lam19 _ _ _ (t tm var19 lam19 app)

app19 : {g:_}->{a:_}->{B:_} -> Tm19 g (arr19 a B) -> Tm19 g a -> Tm19 g B
app19 = \ t, u, tm, var19, lam19, app19 => app19 _ _ _ (t tm var19 lam19 app19) (u tm var19 lam19 app19)

v019 : {g:_}->{a:_} -> Tm19 (snoc19 g a) a
v019 = var19 vz19

v119 : {g:_}->{a:_}-> {B:_}-> Tm19 (snoc19 (snoc19 g a) B) a
v119 = var19 (vs19 vz19)

v219 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm19 (snoc19 (snoc19 (snoc19 g a) B) C) a
v219 = var19 (vs19 (vs19 vz19))

v319 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm19 (snoc19 (snoc19 (snoc19 (snoc19 g a) B) C) D) a
v319 = var19 (vs19 (vs19 (vs19 vz19)))

v419 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm19 (snoc19 (snoc19 (snoc19 (snoc19 (snoc19 g a) B) C) D) E) a
v419 = var19 (vs19 (vs19 (vs19 (vs19 vz19))))

test19 : {g:_}-> {a:_} -> Tm19 g (arr19 (arr19 a a) (arr19 a a))
test19  = lam19 (lam19 (app19 v119 (app19 v119 (app19 v119 (app19 v119 (app19 v119 (app19 v119 v019)))))))
Ty20 : Type
Ty20 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty20 : Ty20
empty20 = \ _, empty, _ => empty

arr20 : Ty20 -> Ty20 -> Ty20
arr20 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con20 : Type
Con20 = (Con20 : Type)
 ->(nil  : Con20)
 ->(snoc : Con20 -> Ty20 -> Con20)
 -> Con20

nil20 : Con20
nil20 = \ con, nil20, snoc => nil20

snoc20 : Con20 -> Ty20 -> Con20
snoc20 = \ g, a, con, nil20, snoc20 => snoc20 (g con nil20 snoc20) a

Var20 : Con20 -> Ty20 -> Type
Var20 = \ g, a =>
    (Var20 : Con20 -> Ty20 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var20 (snoc20 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var20 g a -> Var20 (snoc20 g b) a)
 -> Var20 g a

vz20 : {g : _}-> {a : _} -> Var20 (snoc20 g a) a
vz20 = \ var, vz20, vs => vz20 _ _

vs20 : {g : _} -> {B : _} -> {a : _} -> Var20 g a -> Var20 (snoc20 g B) a
vs20 = \ x, var, vz20, vs20 => vs20 _ _ _ (x var vz20 vs20)

Tm20 : Con20 -> Ty20 -> Type
Tm20 = \ g, a =>
    (Tm20    : Con20 -> Ty20 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var20 g a -> Tm20 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm20 (snoc20 g a) B -> Tm20 g (arr20 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm20 g (arr20 a B) -> Tm20 g a -> Tm20 g B)
 -> Tm20 g a

var20 : {g : _} -> {a : _} -> Var20 g a -> Tm20 g a
var20 = \ x, tm, var20, lam, app => var20 _ _ x

lam20 : {g : _} -> {a : _} -> {B : _} -> Tm20 (snoc20 g a) B -> Tm20 g (arr20 a B)
lam20 = \ t, tm, var20, lam20, app => lam20 _ _ _ (t tm var20 lam20 app)

app20 : {g:_}->{a:_}->{B:_} -> Tm20 g (arr20 a B) -> Tm20 g a -> Tm20 g B
app20 = \ t, u, tm, var20, lam20, app20 => app20 _ _ _ (t tm var20 lam20 app20) (u tm var20 lam20 app20)

v020 : {g:_}->{a:_} -> Tm20 (snoc20 g a) a
v020 = var20 vz20

v120 : {g:_}->{a:_}-> {B:_}-> Tm20 (snoc20 (snoc20 g a) B) a
v120 = var20 (vs20 vz20)

v220 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm20 (snoc20 (snoc20 (snoc20 g a) B) C) a
v220 = var20 (vs20 (vs20 vz20))

v320 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm20 (snoc20 (snoc20 (snoc20 (snoc20 g a) B) C) D) a
v320 = var20 (vs20 (vs20 (vs20 vz20)))

v420 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm20 (snoc20 (snoc20 (snoc20 (snoc20 (snoc20 g a) B) C) D) E) a
v420 = var20 (vs20 (vs20 (vs20 (vs20 vz20))))

test20 : {g:_}-> {a:_} -> Tm20 g (arr20 (arr20 a a) (arr20 a a))
test20  = lam20 (lam20 (app20 v120 (app20 v120 (app20 v120 (app20 v120 (app20 v120 (app20 v120 v020)))))))
Ty21 : Type
Ty21 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty21 : Ty21
empty21 = \ _, empty, _ => empty

arr21 : Ty21 -> Ty21 -> Ty21
arr21 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con21 : Type
Con21 = (Con21 : Type)
 ->(nil  : Con21)
 ->(snoc : Con21 -> Ty21 -> Con21)
 -> Con21

nil21 : Con21
nil21 = \ con, nil21, snoc => nil21

snoc21 : Con21 -> Ty21 -> Con21
snoc21 = \ g, a, con, nil21, snoc21 => snoc21 (g con nil21 snoc21) a

Var21 : Con21 -> Ty21 -> Type
Var21 = \ g, a =>
    (Var21 : Con21 -> Ty21 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var21 (snoc21 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var21 g a -> Var21 (snoc21 g b) a)
 -> Var21 g a

vz21 : {g : _}-> {a : _} -> Var21 (snoc21 g a) a
vz21 = \ var, vz21, vs => vz21 _ _

vs21 : {g : _} -> {B : _} -> {a : _} -> Var21 g a -> Var21 (snoc21 g B) a
vs21 = \ x, var, vz21, vs21 => vs21 _ _ _ (x var vz21 vs21)

Tm21 : Con21 -> Ty21 -> Type
Tm21 = \ g, a =>
    (Tm21    : Con21 -> Ty21 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var21 g a -> Tm21 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm21 (snoc21 g a) B -> Tm21 g (arr21 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm21 g (arr21 a B) -> Tm21 g a -> Tm21 g B)
 -> Tm21 g a

var21 : {g : _} -> {a : _} -> Var21 g a -> Tm21 g a
var21 = \ x, tm, var21, lam, app => var21 _ _ x

lam21 : {g : _} -> {a : _} -> {B : _} -> Tm21 (snoc21 g a) B -> Tm21 g (arr21 a B)
lam21 = \ t, tm, var21, lam21, app => lam21 _ _ _ (t tm var21 lam21 app)

app21 : {g:_}->{a:_}->{B:_} -> Tm21 g (arr21 a B) -> Tm21 g a -> Tm21 g B
app21 = \ t, u, tm, var21, lam21, app21 => app21 _ _ _ (t tm var21 lam21 app21) (u tm var21 lam21 app21)

v021 : {g:_}->{a:_} -> Tm21 (snoc21 g a) a
v021 = var21 vz21

v121 : {g:_}->{a:_}-> {B:_}-> Tm21 (snoc21 (snoc21 g a) B) a
v121 = var21 (vs21 vz21)

v221 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm21 (snoc21 (snoc21 (snoc21 g a) B) C) a
v221 = var21 (vs21 (vs21 vz21))

v321 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm21 (snoc21 (snoc21 (snoc21 (snoc21 g a) B) C) D) a
v321 = var21 (vs21 (vs21 (vs21 vz21)))

v421 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm21 (snoc21 (snoc21 (snoc21 (snoc21 (snoc21 g a) B) C) D) E) a
v421 = var21 (vs21 (vs21 (vs21 (vs21 vz21))))

test21 : {g:_}-> {a:_} -> Tm21 g (arr21 (arr21 a a) (arr21 a a))
test21  = lam21 (lam21 (app21 v121 (app21 v121 (app21 v121 (app21 v121 (app21 v121 (app21 v121 v021)))))))
Ty22 : Type
Ty22 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty22 : Ty22
empty22 = \ _, empty, _ => empty

arr22 : Ty22 -> Ty22 -> Ty22
arr22 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con22 : Type
Con22 = (Con22 : Type)
 ->(nil  : Con22)
 ->(snoc : Con22 -> Ty22 -> Con22)
 -> Con22

nil22 : Con22
nil22 = \ con, nil22, snoc => nil22

snoc22 : Con22 -> Ty22 -> Con22
snoc22 = \ g, a, con, nil22, snoc22 => snoc22 (g con nil22 snoc22) a

Var22 : Con22 -> Ty22 -> Type
Var22 = \ g, a =>
    (Var22 : Con22 -> Ty22 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var22 (snoc22 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var22 g a -> Var22 (snoc22 g b) a)
 -> Var22 g a

vz22 : {g : _}-> {a : _} -> Var22 (snoc22 g a) a
vz22 = \ var, vz22, vs => vz22 _ _

vs22 : {g : _} -> {B : _} -> {a : _} -> Var22 g a -> Var22 (snoc22 g B) a
vs22 = \ x, var, vz22, vs22 => vs22 _ _ _ (x var vz22 vs22)

Tm22 : Con22 -> Ty22 -> Type
Tm22 = \ g, a =>
    (Tm22    : Con22 -> Ty22 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var22 g a -> Tm22 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm22 (snoc22 g a) B -> Tm22 g (arr22 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm22 g (arr22 a B) -> Tm22 g a -> Tm22 g B)
 -> Tm22 g a

var22 : {g : _} -> {a : _} -> Var22 g a -> Tm22 g a
var22 = \ x, tm, var22, lam, app => var22 _ _ x

lam22 : {g : _} -> {a : _} -> {B : _} -> Tm22 (snoc22 g a) B -> Tm22 g (arr22 a B)
lam22 = \ t, tm, var22, lam22, app => lam22 _ _ _ (t tm var22 lam22 app)

app22 : {g:_}->{a:_}->{B:_} -> Tm22 g (arr22 a B) -> Tm22 g a -> Tm22 g B
app22 = \ t, u, tm, var22, lam22, app22 => app22 _ _ _ (t tm var22 lam22 app22) (u tm var22 lam22 app22)

v022 : {g:_}->{a:_} -> Tm22 (snoc22 g a) a
v022 = var22 vz22

v122 : {g:_}->{a:_}-> {B:_}-> Tm22 (snoc22 (snoc22 g a) B) a
v122 = var22 (vs22 vz22)

v222 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm22 (snoc22 (snoc22 (snoc22 g a) B) C) a
v222 = var22 (vs22 (vs22 vz22))

v322 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm22 (snoc22 (snoc22 (snoc22 (snoc22 g a) B) C) D) a
v322 = var22 (vs22 (vs22 (vs22 vz22)))

v422 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm22 (snoc22 (snoc22 (snoc22 (snoc22 (snoc22 g a) B) C) D) E) a
v422 = var22 (vs22 (vs22 (vs22 (vs22 vz22))))

test22 : {g:_}-> {a:_} -> Tm22 g (arr22 (arr22 a a) (arr22 a a))
test22  = lam22 (lam22 (app22 v122 (app22 v122 (app22 v122 (app22 v122 (app22 v122 (app22 v122 v022)))))))
Ty23 : Type
Ty23 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty23 : Ty23
empty23 = \ _, empty, _ => empty

arr23 : Ty23 -> Ty23 -> Ty23
arr23 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con23 : Type
Con23 = (Con23 : Type)
 ->(nil  : Con23)
 ->(snoc : Con23 -> Ty23 -> Con23)
 -> Con23

nil23 : Con23
nil23 = \ con, nil23, snoc => nil23

snoc23 : Con23 -> Ty23 -> Con23
snoc23 = \ g, a, con, nil23, snoc23 => snoc23 (g con nil23 snoc23) a

Var23 : Con23 -> Ty23 -> Type
Var23 = \ g, a =>
    (Var23 : Con23 -> Ty23 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var23 (snoc23 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var23 g a -> Var23 (snoc23 g b) a)
 -> Var23 g a

vz23 : {g : _}-> {a : _} -> Var23 (snoc23 g a) a
vz23 = \ var, vz23, vs => vz23 _ _

vs23 : {g : _} -> {B : _} -> {a : _} -> Var23 g a -> Var23 (snoc23 g B) a
vs23 = \ x, var, vz23, vs23 => vs23 _ _ _ (x var vz23 vs23)

Tm23 : Con23 -> Ty23 -> Type
Tm23 = \ g, a =>
    (Tm23    : Con23 -> Ty23 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var23 g a -> Tm23 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm23 (snoc23 g a) B -> Tm23 g (arr23 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm23 g (arr23 a B) -> Tm23 g a -> Tm23 g B)
 -> Tm23 g a

var23 : {g : _} -> {a : _} -> Var23 g a -> Tm23 g a
var23 = \ x, tm, var23, lam, app => var23 _ _ x

lam23 : {g : _} -> {a : _} -> {B : _} -> Tm23 (snoc23 g a) B -> Tm23 g (arr23 a B)
lam23 = \ t, tm, var23, lam23, app => lam23 _ _ _ (t tm var23 lam23 app)

app23 : {g:_}->{a:_}->{B:_} -> Tm23 g (arr23 a B) -> Tm23 g a -> Tm23 g B
app23 = \ t, u, tm, var23, lam23, app23 => app23 _ _ _ (t tm var23 lam23 app23) (u tm var23 lam23 app23)

v023 : {g:_}->{a:_} -> Tm23 (snoc23 g a) a
v023 = var23 vz23

v123 : {g:_}->{a:_}-> {B:_}-> Tm23 (snoc23 (snoc23 g a) B) a
v123 = var23 (vs23 vz23)

v223 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm23 (snoc23 (snoc23 (snoc23 g a) B) C) a
v223 = var23 (vs23 (vs23 vz23))

v323 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm23 (snoc23 (snoc23 (snoc23 (snoc23 g a) B) C) D) a
v323 = var23 (vs23 (vs23 (vs23 vz23)))

v423 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm23 (snoc23 (snoc23 (snoc23 (snoc23 (snoc23 g a) B) C) D) E) a
v423 = var23 (vs23 (vs23 (vs23 (vs23 vz23))))

test23 : {g:_}-> {a:_} -> Tm23 g (arr23 (arr23 a a) (arr23 a a))
test23  = lam23 (lam23 (app23 v123 (app23 v123 (app23 v123 (app23 v123 (app23 v123 (app23 v123 v023)))))))
Ty24 : Type
Ty24 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty24 : Ty24
empty24 = \ _, empty, _ => empty

arr24 : Ty24 -> Ty24 -> Ty24
arr24 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con24 : Type
Con24 = (Con24 : Type)
 ->(nil  : Con24)
 ->(snoc : Con24 -> Ty24 -> Con24)
 -> Con24

nil24 : Con24
nil24 = \ con, nil24, snoc => nil24

snoc24 : Con24 -> Ty24 -> Con24
snoc24 = \ g, a, con, nil24, snoc24 => snoc24 (g con nil24 snoc24) a

Var24 : Con24 -> Ty24 -> Type
Var24 = \ g, a =>
    (Var24 : Con24 -> Ty24 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var24 (snoc24 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var24 g a -> Var24 (snoc24 g b) a)
 -> Var24 g a

vz24 : {g : _}-> {a : _} -> Var24 (snoc24 g a) a
vz24 = \ var, vz24, vs => vz24 _ _

vs24 : {g : _} -> {B : _} -> {a : _} -> Var24 g a -> Var24 (snoc24 g B) a
vs24 = \ x, var, vz24, vs24 => vs24 _ _ _ (x var vz24 vs24)

Tm24 : Con24 -> Ty24 -> Type
Tm24 = \ g, a =>
    (Tm24    : Con24 -> Ty24 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var24 g a -> Tm24 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm24 (snoc24 g a) B -> Tm24 g (arr24 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm24 g (arr24 a B) -> Tm24 g a -> Tm24 g B)
 -> Tm24 g a

var24 : {g : _} -> {a : _} -> Var24 g a -> Tm24 g a
var24 = \ x, tm, var24, lam, app => var24 _ _ x

lam24 : {g : _} -> {a : _} -> {B : _} -> Tm24 (snoc24 g a) B -> Tm24 g (arr24 a B)
lam24 = \ t, tm, var24, lam24, app => lam24 _ _ _ (t tm var24 lam24 app)

app24 : {g:_}->{a:_}->{B:_} -> Tm24 g (arr24 a B) -> Tm24 g a -> Tm24 g B
app24 = \ t, u, tm, var24, lam24, app24 => app24 _ _ _ (t tm var24 lam24 app24) (u tm var24 lam24 app24)

v024 : {g:_}->{a:_} -> Tm24 (snoc24 g a) a
v024 = var24 vz24

v124 : {g:_}->{a:_}-> {B:_}-> Tm24 (snoc24 (snoc24 g a) B) a
v124 = var24 (vs24 vz24)

v224 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm24 (snoc24 (snoc24 (snoc24 g a) B) C) a
v224 = var24 (vs24 (vs24 vz24))

v324 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm24 (snoc24 (snoc24 (snoc24 (snoc24 g a) B) C) D) a
v324 = var24 (vs24 (vs24 (vs24 vz24)))

v424 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm24 (snoc24 (snoc24 (snoc24 (snoc24 (snoc24 g a) B) C) D) E) a
v424 = var24 (vs24 (vs24 (vs24 (vs24 vz24))))

test24 : {g:_}-> {a:_} -> Tm24 g (arr24 (arr24 a a) (arr24 a a))
test24  = lam24 (lam24 (app24 v124 (app24 v124 (app24 v124 (app24 v124 (app24 v124 (app24 v124 v024)))))))
Ty25 : Type
Ty25 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty25 : Ty25
empty25 = \ _, empty, _ => empty

arr25 : Ty25 -> Ty25 -> Ty25
arr25 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con25 : Type
Con25 = (Con25 : Type)
 ->(nil  : Con25)
 ->(snoc : Con25 -> Ty25 -> Con25)
 -> Con25

nil25 : Con25
nil25 = \ con, nil25, snoc => nil25

snoc25 : Con25 -> Ty25 -> Con25
snoc25 = \ g, a, con, nil25, snoc25 => snoc25 (g con nil25 snoc25) a

Var25 : Con25 -> Ty25 -> Type
Var25 = \ g, a =>
    (Var25 : Con25 -> Ty25 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var25 (snoc25 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var25 g a -> Var25 (snoc25 g b) a)
 -> Var25 g a

vz25 : {g : _}-> {a : _} -> Var25 (snoc25 g a) a
vz25 = \ var, vz25, vs => vz25 _ _

vs25 : {g : _} -> {B : _} -> {a : _} -> Var25 g a -> Var25 (snoc25 g B) a
vs25 = \ x, var, vz25, vs25 => vs25 _ _ _ (x var vz25 vs25)

Tm25 : Con25 -> Ty25 -> Type
Tm25 = \ g, a =>
    (Tm25    : Con25 -> Ty25 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var25 g a -> Tm25 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm25 (snoc25 g a) B -> Tm25 g (arr25 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm25 g (arr25 a B) -> Tm25 g a -> Tm25 g B)
 -> Tm25 g a

var25 : {g : _} -> {a : _} -> Var25 g a -> Tm25 g a
var25 = \ x, tm, var25, lam, app => var25 _ _ x

lam25 : {g : _} -> {a : _} -> {B : _} -> Tm25 (snoc25 g a) B -> Tm25 g (arr25 a B)
lam25 = \ t, tm, var25, lam25, app => lam25 _ _ _ (t tm var25 lam25 app)

app25 : {g:_}->{a:_}->{B:_} -> Tm25 g (arr25 a B) -> Tm25 g a -> Tm25 g B
app25 = \ t, u, tm, var25, lam25, app25 => app25 _ _ _ (t tm var25 lam25 app25) (u tm var25 lam25 app25)

v025 : {g:_}->{a:_} -> Tm25 (snoc25 g a) a
v025 = var25 vz25

v125 : {g:_}->{a:_}-> {B:_}-> Tm25 (snoc25 (snoc25 g a) B) a
v125 = var25 (vs25 vz25)

v225 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm25 (snoc25 (snoc25 (snoc25 g a) B) C) a
v225 = var25 (vs25 (vs25 vz25))

v325 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm25 (snoc25 (snoc25 (snoc25 (snoc25 g a) B) C) D) a
v325 = var25 (vs25 (vs25 (vs25 vz25)))

v425 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm25 (snoc25 (snoc25 (snoc25 (snoc25 (snoc25 g a) B) C) D) E) a
v425 = var25 (vs25 (vs25 (vs25 (vs25 vz25))))

test25 : {g:_}-> {a:_} -> Tm25 g (arr25 (arr25 a a) (arr25 a a))
test25  = lam25 (lam25 (app25 v125 (app25 v125 (app25 v125 (app25 v125 (app25 v125 (app25 v125 v025)))))))
Ty26 : Type
Ty26 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty26 : Ty26
empty26 = \ _, empty, _ => empty

arr26 : Ty26 -> Ty26 -> Ty26
arr26 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con26 : Type
Con26 = (Con26 : Type)
 ->(nil  : Con26)
 ->(snoc : Con26 -> Ty26 -> Con26)
 -> Con26

nil26 : Con26
nil26 = \ con, nil26, snoc => nil26

snoc26 : Con26 -> Ty26 -> Con26
snoc26 = \ g, a, con, nil26, snoc26 => snoc26 (g con nil26 snoc26) a

Var26 : Con26 -> Ty26 -> Type
Var26 = \ g, a =>
    (Var26 : Con26 -> Ty26 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var26 (snoc26 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var26 g a -> Var26 (snoc26 g b) a)
 -> Var26 g a

vz26 : {g : _}-> {a : _} -> Var26 (snoc26 g a) a
vz26 = \ var, vz26, vs => vz26 _ _

vs26 : {g : _} -> {B : _} -> {a : _} -> Var26 g a -> Var26 (snoc26 g B) a
vs26 = \ x, var, vz26, vs26 => vs26 _ _ _ (x var vz26 vs26)

Tm26 : Con26 -> Ty26 -> Type
Tm26 = \ g, a =>
    (Tm26    : Con26 -> Ty26 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var26 g a -> Tm26 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm26 (snoc26 g a) B -> Tm26 g (arr26 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm26 g (arr26 a B) -> Tm26 g a -> Tm26 g B)
 -> Tm26 g a

var26 : {g : _} -> {a : _} -> Var26 g a -> Tm26 g a
var26 = \ x, tm, var26, lam, app => var26 _ _ x

lam26 : {g : _} -> {a : _} -> {B : _} -> Tm26 (snoc26 g a) B -> Tm26 g (arr26 a B)
lam26 = \ t, tm, var26, lam26, app => lam26 _ _ _ (t tm var26 lam26 app)

app26 : {g:_}->{a:_}->{B:_} -> Tm26 g (arr26 a B) -> Tm26 g a -> Tm26 g B
app26 = \ t, u, tm, var26, lam26, app26 => app26 _ _ _ (t tm var26 lam26 app26) (u tm var26 lam26 app26)

v026 : {g:_}->{a:_} -> Tm26 (snoc26 g a) a
v026 = var26 vz26

v126 : {g:_}->{a:_}-> {B:_}-> Tm26 (snoc26 (snoc26 g a) B) a
v126 = var26 (vs26 vz26)

v226 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm26 (snoc26 (snoc26 (snoc26 g a) B) C) a
v226 = var26 (vs26 (vs26 vz26))

v326 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm26 (snoc26 (snoc26 (snoc26 (snoc26 g a) B) C) D) a
v326 = var26 (vs26 (vs26 (vs26 vz26)))

v426 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm26 (snoc26 (snoc26 (snoc26 (snoc26 (snoc26 g a) B) C) D) E) a
v426 = var26 (vs26 (vs26 (vs26 (vs26 vz26))))

test26 : {g:_}-> {a:_} -> Tm26 g (arr26 (arr26 a a) (arr26 a a))
test26  = lam26 (lam26 (app26 v126 (app26 v126 (app26 v126 (app26 v126 (app26 v126 (app26 v126 v026)))))))
Ty27 : Type
Ty27 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty27 : Ty27
empty27 = \ _, empty, _ => empty

arr27 : Ty27 -> Ty27 -> Ty27
arr27 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con27 : Type
Con27 = (Con27 : Type)
 ->(nil  : Con27)
 ->(snoc : Con27 -> Ty27 -> Con27)
 -> Con27

nil27 : Con27
nil27 = \ con, nil27, snoc => nil27

snoc27 : Con27 -> Ty27 -> Con27
snoc27 = \ g, a, con, nil27, snoc27 => snoc27 (g con nil27 snoc27) a

Var27 : Con27 -> Ty27 -> Type
Var27 = \ g, a =>
    (Var27 : Con27 -> Ty27 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var27 (snoc27 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var27 g a -> Var27 (snoc27 g b) a)
 -> Var27 g a

vz27 : {g : _}-> {a : _} -> Var27 (snoc27 g a) a
vz27 = \ var, vz27, vs => vz27 _ _

vs27 : {g : _} -> {B : _} -> {a : _} -> Var27 g a -> Var27 (snoc27 g B) a
vs27 = \ x, var, vz27, vs27 => vs27 _ _ _ (x var vz27 vs27)

Tm27 : Con27 -> Ty27 -> Type
Tm27 = \ g, a =>
    (Tm27    : Con27 -> Ty27 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var27 g a -> Tm27 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm27 (snoc27 g a) B -> Tm27 g (arr27 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm27 g (arr27 a B) -> Tm27 g a -> Tm27 g B)
 -> Tm27 g a

var27 : {g : _} -> {a : _} -> Var27 g a -> Tm27 g a
var27 = \ x, tm, var27, lam, app => var27 _ _ x

lam27 : {g : _} -> {a : _} -> {B : _} -> Tm27 (snoc27 g a) B -> Tm27 g (arr27 a B)
lam27 = \ t, tm, var27, lam27, app => lam27 _ _ _ (t tm var27 lam27 app)

app27 : {g:_}->{a:_}->{B:_} -> Tm27 g (arr27 a B) -> Tm27 g a -> Tm27 g B
app27 = \ t, u, tm, var27, lam27, app27 => app27 _ _ _ (t tm var27 lam27 app27) (u tm var27 lam27 app27)

v027 : {g:_}->{a:_} -> Tm27 (snoc27 g a) a
v027 = var27 vz27

v127 : {g:_}->{a:_}-> {B:_}-> Tm27 (snoc27 (snoc27 g a) B) a
v127 = var27 (vs27 vz27)

v227 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm27 (snoc27 (snoc27 (snoc27 g a) B) C) a
v227 = var27 (vs27 (vs27 vz27))

v327 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm27 (snoc27 (snoc27 (snoc27 (snoc27 g a) B) C) D) a
v327 = var27 (vs27 (vs27 (vs27 vz27)))

v427 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm27 (snoc27 (snoc27 (snoc27 (snoc27 (snoc27 g a) B) C) D) E) a
v427 = var27 (vs27 (vs27 (vs27 (vs27 vz27))))

test27 : {g:_}-> {a:_} -> Tm27 g (arr27 (arr27 a a) (arr27 a a))
test27  = lam27 (lam27 (app27 v127 (app27 v127 (app27 v127 (app27 v127 (app27 v127 (app27 v127 v027)))))))
Ty28 : Type
Ty28 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty28 : Ty28
empty28 = \ _, empty, _ => empty

arr28 : Ty28 -> Ty28 -> Ty28
arr28 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con28 : Type
Con28 = (Con28 : Type)
 ->(nil  : Con28)
 ->(snoc : Con28 -> Ty28 -> Con28)
 -> Con28

nil28 : Con28
nil28 = \ con, nil28, snoc => nil28

snoc28 : Con28 -> Ty28 -> Con28
snoc28 = \ g, a, con, nil28, snoc28 => snoc28 (g con nil28 snoc28) a

Var28 : Con28 -> Ty28 -> Type
Var28 = \ g, a =>
    (Var28 : Con28 -> Ty28 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var28 (snoc28 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var28 g a -> Var28 (snoc28 g b) a)
 -> Var28 g a

vz28 : {g : _}-> {a : _} -> Var28 (snoc28 g a) a
vz28 = \ var, vz28, vs => vz28 _ _

vs28 : {g : _} -> {B : _} -> {a : _} -> Var28 g a -> Var28 (snoc28 g B) a
vs28 = \ x, var, vz28, vs28 => vs28 _ _ _ (x var vz28 vs28)

Tm28 : Con28 -> Ty28 -> Type
Tm28 = \ g, a =>
    (Tm28    : Con28 -> Ty28 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var28 g a -> Tm28 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm28 (snoc28 g a) B -> Tm28 g (arr28 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm28 g (arr28 a B) -> Tm28 g a -> Tm28 g B)
 -> Tm28 g a

var28 : {g : _} -> {a : _} -> Var28 g a -> Tm28 g a
var28 = \ x, tm, var28, lam, app => var28 _ _ x

lam28 : {g : _} -> {a : _} -> {B : _} -> Tm28 (snoc28 g a) B -> Tm28 g (arr28 a B)
lam28 = \ t, tm, var28, lam28, app => lam28 _ _ _ (t tm var28 lam28 app)

app28 : {g:_}->{a:_}->{B:_} -> Tm28 g (arr28 a B) -> Tm28 g a -> Tm28 g B
app28 = \ t, u, tm, var28, lam28, app28 => app28 _ _ _ (t tm var28 lam28 app28) (u tm var28 lam28 app28)

v028 : {g:_}->{a:_} -> Tm28 (snoc28 g a) a
v028 = var28 vz28

v128 : {g:_}->{a:_}-> {B:_}-> Tm28 (snoc28 (snoc28 g a) B) a
v128 = var28 (vs28 vz28)

v228 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm28 (snoc28 (snoc28 (snoc28 g a) B) C) a
v228 = var28 (vs28 (vs28 vz28))

v328 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm28 (snoc28 (snoc28 (snoc28 (snoc28 g a) B) C) D) a
v328 = var28 (vs28 (vs28 (vs28 vz28)))

v428 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm28 (snoc28 (snoc28 (snoc28 (snoc28 (snoc28 g a) B) C) D) E) a
v428 = var28 (vs28 (vs28 (vs28 (vs28 vz28))))

test28 : {g:_}-> {a:_} -> Tm28 g (arr28 (arr28 a a) (arr28 a a))
test28  = lam28 (lam28 (app28 v128 (app28 v128 (app28 v128 (app28 v128 (app28 v128 (app28 v128 v028)))))))
Ty29 : Type
Ty29 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty29 : Ty29
empty29 = \ _, empty, _ => empty

arr29 : Ty29 -> Ty29 -> Ty29
arr29 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con29 : Type
Con29 = (Con29 : Type)
 ->(nil  : Con29)
 ->(snoc : Con29 -> Ty29 -> Con29)
 -> Con29

nil29 : Con29
nil29 = \ con, nil29, snoc => nil29

snoc29 : Con29 -> Ty29 -> Con29
snoc29 = \ g, a, con, nil29, snoc29 => snoc29 (g con nil29 snoc29) a

Var29 : Con29 -> Ty29 -> Type
Var29 = \ g, a =>
    (Var29 : Con29 -> Ty29 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var29 (snoc29 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var29 g a -> Var29 (snoc29 g b) a)
 -> Var29 g a

vz29 : {g : _}-> {a : _} -> Var29 (snoc29 g a) a
vz29 = \ var, vz29, vs => vz29 _ _

vs29 : {g : _} -> {B : _} -> {a : _} -> Var29 g a -> Var29 (snoc29 g B) a
vs29 = \ x, var, vz29, vs29 => vs29 _ _ _ (x var vz29 vs29)

Tm29 : Con29 -> Ty29 -> Type
Tm29 = \ g, a =>
    (Tm29    : Con29 -> Ty29 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var29 g a -> Tm29 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm29 (snoc29 g a) B -> Tm29 g (arr29 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm29 g (arr29 a B) -> Tm29 g a -> Tm29 g B)
 -> Tm29 g a

var29 : {g : _} -> {a : _} -> Var29 g a -> Tm29 g a
var29 = \ x, tm, var29, lam, app => var29 _ _ x

lam29 : {g : _} -> {a : _} -> {B : _} -> Tm29 (snoc29 g a) B -> Tm29 g (arr29 a B)
lam29 = \ t, tm, var29, lam29, app => lam29 _ _ _ (t tm var29 lam29 app)

app29 : {g:_}->{a:_}->{B:_} -> Tm29 g (arr29 a B) -> Tm29 g a -> Tm29 g B
app29 = \ t, u, tm, var29, lam29, app29 => app29 _ _ _ (t tm var29 lam29 app29) (u tm var29 lam29 app29)

v029 : {g:_}->{a:_} -> Tm29 (snoc29 g a) a
v029 = var29 vz29

v129 : {g:_}->{a:_}-> {B:_}-> Tm29 (snoc29 (snoc29 g a) B) a
v129 = var29 (vs29 vz29)

v229 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm29 (snoc29 (snoc29 (snoc29 g a) B) C) a
v229 = var29 (vs29 (vs29 vz29))

v329 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm29 (snoc29 (snoc29 (snoc29 (snoc29 g a) B) C) D) a
v329 = var29 (vs29 (vs29 (vs29 vz29)))

v429 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm29 (snoc29 (snoc29 (snoc29 (snoc29 (snoc29 g a) B) C) D) E) a
v429 = var29 (vs29 (vs29 (vs29 (vs29 vz29))))

test29 : {g:_}-> {a:_} -> Tm29 g (arr29 (arr29 a a) (arr29 a a))
test29  = lam29 (lam29 (app29 v129 (app29 v129 (app29 v129 (app29 v129 (app29 v129 (app29 v129 v029)))))))
Ty30 : Type
Ty30 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty30 : Ty30
empty30 = \ _, empty, _ => empty

arr30 : Ty30 -> Ty30 -> Ty30
arr30 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con30 : Type
Con30 = (Con30 : Type)
 ->(nil  : Con30)
 ->(snoc : Con30 -> Ty30 -> Con30)
 -> Con30

nil30 : Con30
nil30 = \ con, nil30, snoc => nil30

snoc30 : Con30 -> Ty30 -> Con30
snoc30 = \ g, a, con, nil30, snoc30 => snoc30 (g con nil30 snoc30) a

Var30 : Con30 -> Ty30 -> Type
Var30 = \ g, a =>
    (Var30 : Con30 -> Ty30 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var30 (snoc30 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var30 g a -> Var30 (snoc30 g b) a)
 -> Var30 g a

vz30 : {g : _}-> {a : _} -> Var30 (snoc30 g a) a
vz30 = \ var, vz30, vs => vz30 _ _

vs30 : {g : _} -> {B : _} -> {a : _} -> Var30 g a -> Var30 (snoc30 g B) a
vs30 = \ x, var, vz30, vs30 => vs30 _ _ _ (x var vz30 vs30)

Tm30 : Con30 -> Ty30 -> Type
Tm30 = \ g, a =>
    (Tm30    : Con30 -> Ty30 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var30 g a -> Tm30 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm30 (snoc30 g a) B -> Tm30 g (arr30 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm30 g (arr30 a B) -> Tm30 g a -> Tm30 g B)
 -> Tm30 g a

var30 : {g : _} -> {a : _} -> Var30 g a -> Tm30 g a
var30 = \ x, tm, var30, lam, app => var30 _ _ x

lam30 : {g : _} -> {a : _} -> {B : _} -> Tm30 (snoc30 g a) B -> Tm30 g (arr30 a B)
lam30 = \ t, tm, var30, lam30, app => lam30 _ _ _ (t tm var30 lam30 app)

app30 : {g:_}->{a:_}->{B:_} -> Tm30 g (arr30 a B) -> Tm30 g a -> Tm30 g B
app30 = \ t, u, tm, var30, lam30, app30 => app30 _ _ _ (t tm var30 lam30 app30) (u tm var30 lam30 app30)

v030 : {g:_}->{a:_} -> Tm30 (snoc30 g a) a
v030 = var30 vz30

v130 : {g:_}->{a:_}-> {B:_}-> Tm30 (snoc30 (snoc30 g a) B) a
v130 = var30 (vs30 vz30)

v230 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm30 (snoc30 (snoc30 (snoc30 g a) B) C) a
v230 = var30 (vs30 (vs30 vz30))

v330 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm30 (snoc30 (snoc30 (snoc30 (snoc30 g a) B) C) D) a
v330 = var30 (vs30 (vs30 (vs30 vz30)))

v430 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm30 (snoc30 (snoc30 (snoc30 (snoc30 (snoc30 g a) B) C) D) E) a
v430 = var30 (vs30 (vs30 (vs30 (vs30 vz30))))

test30 : {g:_}-> {a:_} -> Tm30 g (arr30 (arr30 a a) (arr30 a a))
test30  = lam30 (lam30 (app30 v130 (app30 v130 (app30 v130 (app30 v130 (app30 v130 (app30 v130 v030)))))))
Ty31 : Type
Ty31 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty31 : Ty31
empty31 = \ _, empty, _ => empty

arr31 : Ty31 -> Ty31 -> Ty31
arr31 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con31 : Type
Con31 = (Con31 : Type)
 ->(nil  : Con31)
 ->(snoc : Con31 -> Ty31 -> Con31)
 -> Con31

nil31 : Con31
nil31 = \ con, nil31, snoc => nil31

snoc31 : Con31 -> Ty31 -> Con31
snoc31 = \ g, a, con, nil31, snoc31 => snoc31 (g con nil31 snoc31) a

Var31 : Con31 -> Ty31 -> Type
Var31 = \ g, a =>
    (Var31 : Con31 -> Ty31 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var31 (snoc31 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var31 g a -> Var31 (snoc31 g b) a)
 -> Var31 g a

vz31 : {g : _}-> {a : _} -> Var31 (snoc31 g a) a
vz31 = \ var, vz31, vs => vz31 _ _

vs31 : {g : _} -> {B : _} -> {a : _} -> Var31 g a -> Var31 (snoc31 g B) a
vs31 = \ x, var, vz31, vs31 => vs31 _ _ _ (x var vz31 vs31)

Tm31 : Con31 -> Ty31 -> Type
Tm31 = \ g, a =>
    (Tm31    : Con31 -> Ty31 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var31 g a -> Tm31 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm31 (snoc31 g a) B -> Tm31 g (arr31 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm31 g (arr31 a B) -> Tm31 g a -> Tm31 g B)
 -> Tm31 g a

var31 : {g : _} -> {a : _} -> Var31 g a -> Tm31 g a
var31 = \ x, tm, var31, lam, app => var31 _ _ x

lam31 : {g : _} -> {a : _} -> {B : _} -> Tm31 (snoc31 g a) B -> Tm31 g (arr31 a B)
lam31 = \ t, tm, var31, lam31, app => lam31 _ _ _ (t tm var31 lam31 app)

app31 : {g:_}->{a:_}->{B:_} -> Tm31 g (arr31 a B) -> Tm31 g a -> Tm31 g B
app31 = \ t, u, tm, var31, lam31, app31 => app31 _ _ _ (t tm var31 lam31 app31) (u tm var31 lam31 app31)

v031 : {g:_}->{a:_} -> Tm31 (snoc31 g a) a
v031 = var31 vz31

v131 : {g:_}->{a:_}-> {B:_}-> Tm31 (snoc31 (snoc31 g a) B) a
v131 = var31 (vs31 vz31)

v231 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm31 (snoc31 (snoc31 (snoc31 g a) B) C) a
v231 = var31 (vs31 (vs31 vz31))

v331 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm31 (snoc31 (snoc31 (snoc31 (snoc31 g a) B) C) D) a
v331 = var31 (vs31 (vs31 (vs31 vz31)))

v431 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm31 (snoc31 (snoc31 (snoc31 (snoc31 (snoc31 g a) B) C) D) E) a
v431 = var31 (vs31 (vs31 (vs31 (vs31 vz31))))

test31 : {g:_}-> {a:_} -> Tm31 g (arr31 (arr31 a a) (arr31 a a))
test31  = lam31 (lam31 (app31 v131 (app31 v131 (app31 v131 (app31 v131 (app31 v131 (app31 v131 v031)))))))
Ty32 : Type
Ty32 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty32 : Ty32
empty32 = \ _, empty, _ => empty

arr32 : Ty32 -> Ty32 -> Ty32
arr32 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con32 : Type
Con32 = (Con32 : Type)
 ->(nil  : Con32)
 ->(snoc : Con32 -> Ty32 -> Con32)
 -> Con32

nil32 : Con32
nil32 = \ con, nil32, snoc => nil32

snoc32 : Con32 -> Ty32 -> Con32
snoc32 = \ g, a, con, nil32, snoc32 => snoc32 (g con nil32 snoc32) a

Var32 : Con32 -> Ty32 -> Type
Var32 = \ g, a =>
    (Var32 : Con32 -> Ty32 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var32 (snoc32 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var32 g a -> Var32 (snoc32 g b) a)
 -> Var32 g a

vz32 : {g : _}-> {a : _} -> Var32 (snoc32 g a) a
vz32 = \ var, vz32, vs => vz32 _ _

vs32 : {g : _} -> {B : _} -> {a : _} -> Var32 g a -> Var32 (snoc32 g B) a
vs32 = \ x, var, vz32, vs32 => vs32 _ _ _ (x var vz32 vs32)

Tm32 : Con32 -> Ty32 -> Type
Tm32 = \ g, a =>
    (Tm32    : Con32 -> Ty32 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var32 g a -> Tm32 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm32 (snoc32 g a) B -> Tm32 g (arr32 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm32 g (arr32 a B) -> Tm32 g a -> Tm32 g B)
 -> Tm32 g a

var32 : {g : _} -> {a : _} -> Var32 g a -> Tm32 g a
var32 = \ x, tm, var32, lam, app => var32 _ _ x

lam32 : {g : _} -> {a : _} -> {B : _} -> Tm32 (snoc32 g a) B -> Tm32 g (arr32 a B)
lam32 = \ t, tm, var32, lam32, app => lam32 _ _ _ (t tm var32 lam32 app)

app32 : {g:_}->{a:_}->{B:_} -> Tm32 g (arr32 a B) -> Tm32 g a -> Tm32 g B
app32 = \ t, u, tm, var32, lam32, app32 => app32 _ _ _ (t tm var32 lam32 app32) (u tm var32 lam32 app32)

v032 : {g:_}->{a:_} -> Tm32 (snoc32 g a) a
v032 = var32 vz32

v132 : {g:_}->{a:_}-> {B:_}-> Tm32 (snoc32 (snoc32 g a) B) a
v132 = var32 (vs32 vz32)

v232 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm32 (snoc32 (snoc32 (snoc32 g a) B) C) a
v232 = var32 (vs32 (vs32 vz32))

v332 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm32 (snoc32 (snoc32 (snoc32 (snoc32 g a) B) C) D) a
v332 = var32 (vs32 (vs32 (vs32 vz32)))

v432 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm32 (snoc32 (snoc32 (snoc32 (snoc32 (snoc32 g a) B) C) D) E) a
v432 = var32 (vs32 (vs32 (vs32 (vs32 vz32))))

test32 : {g:_}-> {a:_} -> Tm32 g (arr32 (arr32 a a) (arr32 a a))
test32  = lam32 (lam32 (app32 v132 (app32 v132 (app32 v132 (app32 v132 (app32 v132 (app32 v132 v032)))))))
Ty33 : Type
Ty33 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty33 : Ty33
empty33 = \ _, empty, _ => empty

arr33 : Ty33 -> Ty33 -> Ty33
arr33 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con33 : Type
Con33 = (Con33 : Type)
 ->(nil  : Con33)
 ->(snoc : Con33 -> Ty33 -> Con33)
 -> Con33

nil33 : Con33
nil33 = \ con, nil33, snoc => nil33

snoc33 : Con33 -> Ty33 -> Con33
snoc33 = \ g, a, con, nil33, snoc33 => snoc33 (g con nil33 snoc33) a

Var33 : Con33 -> Ty33 -> Type
Var33 = \ g, a =>
    (Var33 : Con33 -> Ty33 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var33 (snoc33 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var33 g a -> Var33 (snoc33 g b) a)
 -> Var33 g a

vz33 : {g : _}-> {a : _} -> Var33 (snoc33 g a) a
vz33 = \ var, vz33, vs => vz33 _ _

vs33 : {g : _} -> {B : _} -> {a : _} -> Var33 g a -> Var33 (snoc33 g B) a
vs33 = \ x, var, vz33, vs33 => vs33 _ _ _ (x var vz33 vs33)

Tm33 : Con33 -> Ty33 -> Type
Tm33 = \ g, a =>
    (Tm33    : Con33 -> Ty33 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var33 g a -> Tm33 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm33 (snoc33 g a) B -> Tm33 g (arr33 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm33 g (arr33 a B) -> Tm33 g a -> Tm33 g B)
 -> Tm33 g a

var33 : {g : _} -> {a : _} -> Var33 g a -> Tm33 g a
var33 = \ x, tm, var33, lam, app => var33 _ _ x

lam33 : {g : _} -> {a : _} -> {B : _} -> Tm33 (snoc33 g a) B -> Tm33 g (arr33 a B)
lam33 = \ t, tm, var33, lam33, app => lam33 _ _ _ (t tm var33 lam33 app)

app33 : {g:_}->{a:_}->{B:_} -> Tm33 g (arr33 a B) -> Tm33 g a -> Tm33 g B
app33 = \ t, u, tm, var33, lam33, app33 => app33 _ _ _ (t tm var33 lam33 app33) (u tm var33 lam33 app33)

v033 : {g:_}->{a:_} -> Tm33 (snoc33 g a) a
v033 = var33 vz33

v133 : {g:_}->{a:_}-> {B:_}-> Tm33 (snoc33 (snoc33 g a) B) a
v133 = var33 (vs33 vz33)

v233 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm33 (snoc33 (snoc33 (snoc33 g a) B) C) a
v233 = var33 (vs33 (vs33 vz33))

v333 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm33 (snoc33 (snoc33 (snoc33 (snoc33 g a) B) C) D) a
v333 = var33 (vs33 (vs33 (vs33 vz33)))

v433 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm33 (snoc33 (snoc33 (snoc33 (snoc33 (snoc33 g a) B) C) D) E) a
v433 = var33 (vs33 (vs33 (vs33 (vs33 vz33))))

test33 : {g:_}-> {a:_} -> Tm33 g (arr33 (arr33 a a) (arr33 a a))
test33  = lam33 (lam33 (app33 v133 (app33 v133 (app33 v133 (app33 v133 (app33 v133 (app33 v133 v033)))))))
Ty34 : Type
Ty34 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty34 : Ty34
empty34 = \ _, empty, _ => empty

arr34 : Ty34 -> Ty34 -> Ty34
arr34 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con34 : Type
Con34 = (Con34 : Type)
 ->(nil  : Con34)
 ->(snoc : Con34 -> Ty34 -> Con34)
 -> Con34

nil34 : Con34
nil34 = \ con, nil34, snoc => nil34

snoc34 : Con34 -> Ty34 -> Con34
snoc34 = \ g, a, con, nil34, snoc34 => snoc34 (g con nil34 snoc34) a

Var34 : Con34 -> Ty34 -> Type
Var34 = \ g, a =>
    (Var34 : Con34 -> Ty34 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var34 (snoc34 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var34 g a -> Var34 (snoc34 g b) a)
 -> Var34 g a

vz34 : {g : _}-> {a : _} -> Var34 (snoc34 g a) a
vz34 = \ var, vz34, vs => vz34 _ _

vs34 : {g : _} -> {B : _} -> {a : _} -> Var34 g a -> Var34 (snoc34 g B) a
vs34 = \ x, var, vz34, vs34 => vs34 _ _ _ (x var vz34 vs34)

Tm34 : Con34 -> Ty34 -> Type
Tm34 = \ g, a =>
    (Tm34    : Con34 -> Ty34 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var34 g a -> Tm34 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm34 (snoc34 g a) B -> Tm34 g (arr34 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm34 g (arr34 a B) -> Tm34 g a -> Tm34 g B)
 -> Tm34 g a

var34 : {g : _} -> {a : _} -> Var34 g a -> Tm34 g a
var34 = \ x, tm, var34, lam, app => var34 _ _ x

lam34 : {g : _} -> {a : _} -> {B : _} -> Tm34 (snoc34 g a) B -> Tm34 g (arr34 a B)
lam34 = \ t, tm, var34, lam34, app => lam34 _ _ _ (t tm var34 lam34 app)

app34 : {g:_}->{a:_}->{B:_} -> Tm34 g (arr34 a B) -> Tm34 g a -> Tm34 g B
app34 = \ t, u, tm, var34, lam34, app34 => app34 _ _ _ (t tm var34 lam34 app34) (u tm var34 lam34 app34)

v034 : {g:_}->{a:_} -> Tm34 (snoc34 g a) a
v034 = var34 vz34

v134 : {g:_}->{a:_}-> {B:_}-> Tm34 (snoc34 (snoc34 g a) B) a
v134 = var34 (vs34 vz34)

v234 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm34 (snoc34 (snoc34 (snoc34 g a) B) C) a
v234 = var34 (vs34 (vs34 vz34))

v334 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm34 (snoc34 (snoc34 (snoc34 (snoc34 g a) B) C) D) a
v334 = var34 (vs34 (vs34 (vs34 vz34)))

v434 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm34 (snoc34 (snoc34 (snoc34 (snoc34 (snoc34 g a) B) C) D) E) a
v434 = var34 (vs34 (vs34 (vs34 (vs34 vz34))))

test34 : {g:_}-> {a:_} -> Tm34 g (arr34 (arr34 a a) (arr34 a a))
test34  = lam34 (lam34 (app34 v134 (app34 v134 (app34 v134 (app34 v134 (app34 v134 (app34 v134 v034)))))))
Ty35 : Type
Ty35 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty35 : Ty35
empty35 = \ _, empty, _ => empty

arr35 : Ty35 -> Ty35 -> Ty35
arr35 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con35 : Type
Con35 = (Con35 : Type)
 ->(nil  : Con35)
 ->(snoc : Con35 -> Ty35 -> Con35)
 -> Con35

nil35 : Con35
nil35 = \ con, nil35, snoc => nil35

snoc35 : Con35 -> Ty35 -> Con35
snoc35 = \ g, a, con, nil35, snoc35 => snoc35 (g con nil35 snoc35) a

Var35 : Con35 -> Ty35 -> Type
Var35 = \ g, a =>
    (Var35 : Con35 -> Ty35 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var35 (snoc35 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var35 g a -> Var35 (snoc35 g b) a)
 -> Var35 g a

vz35 : {g : _}-> {a : _} -> Var35 (snoc35 g a) a
vz35 = \ var, vz35, vs => vz35 _ _

vs35 : {g : _} -> {B : _} -> {a : _} -> Var35 g a -> Var35 (snoc35 g B) a
vs35 = \ x, var, vz35, vs35 => vs35 _ _ _ (x var vz35 vs35)

Tm35 : Con35 -> Ty35 -> Type
Tm35 = \ g, a =>
    (Tm35    : Con35 -> Ty35 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var35 g a -> Tm35 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm35 (snoc35 g a) B -> Tm35 g (arr35 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm35 g (arr35 a B) -> Tm35 g a -> Tm35 g B)
 -> Tm35 g a

var35 : {g : _} -> {a : _} -> Var35 g a -> Tm35 g a
var35 = \ x, tm, var35, lam, app => var35 _ _ x

lam35 : {g : _} -> {a : _} -> {B : _} -> Tm35 (snoc35 g a) B -> Tm35 g (arr35 a B)
lam35 = \ t, tm, var35, lam35, app => lam35 _ _ _ (t tm var35 lam35 app)

app35 : {g:_}->{a:_}->{B:_} -> Tm35 g (arr35 a B) -> Tm35 g a -> Tm35 g B
app35 = \ t, u, tm, var35, lam35, app35 => app35 _ _ _ (t tm var35 lam35 app35) (u tm var35 lam35 app35)

v035 : {g:_}->{a:_} -> Tm35 (snoc35 g a) a
v035 = var35 vz35

v135 : {g:_}->{a:_}-> {B:_}-> Tm35 (snoc35 (snoc35 g a) B) a
v135 = var35 (vs35 vz35)

v235 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm35 (snoc35 (snoc35 (snoc35 g a) B) C) a
v235 = var35 (vs35 (vs35 vz35))

v335 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm35 (snoc35 (snoc35 (snoc35 (snoc35 g a) B) C) D) a
v335 = var35 (vs35 (vs35 (vs35 vz35)))

v435 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm35 (snoc35 (snoc35 (snoc35 (snoc35 (snoc35 g a) B) C) D) E) a
v435 = var35 (vs35 (vs35 (vs35 (vs35 vz35))))

test35 : {g:_}-> {a:_} -> Tm35 g (arr35 (arr35 a a) (arr35 a a))
test35  = lam35 (lam35 (app35 v135 (app35 v135 (app35 v135 (app35 v135 (app35 v135 (app35 v135 v035)))))))
Ty36 : Type
Ty36 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty36 : Ty36
empty36 = \ _, empty, _ => empty

arr36 : Ty36 -> Ty36 -> Ty36
arr36 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con36 : Type
Con36 = (Con36 : Type)
 ->(nil  : Con36)
 ->(snoc : Con36 -> Ty36 -> Con36)
 -> Con36

nil36 : Con36
nil36 = \ con, nil36, snoc => nil36

snoc36 : Con36 -> Ty36 -> Con36
snoc36 = \ g, a, con, nil36, snoc36 => snoc36 (g con nil36 snoc36) a

Var36 : Con36 -> Ty36 -> Type
Var36 = \ g, a =>
    (Var36 : Con36 -> Ty36 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var36 (snoc36 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var36 g a -> Var36 (snoc36 g b) a)
 -> Var36 g a

vz36 : {g : _}-> {a : _} -> Var36 (snoc36 g a) a
vz36 = \ var, vz36, vs => vz36 _ _

vs36 : {g : _} -> {B : _} -> {a : _} -> Var36 g a -> Var36 (snoc36 g B) a
vs36 = \ x, var, vz36, vs36 => vs36 _ _ _ (x var vz36 vs36)

Tm36 : Con36 -> Ty36 -> Type
Tm36 = \ g, a =>
    (Tm36    : Con36 -> Ty36 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var36 g a -> Tm36 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm36 (snoc36 g a) B -> Tm36 g (arr36 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm36 g (arr36 a B) -> Tm36 g a -> Tm36 g B)
 -> Tm36 g a

var36 : {g : _} -> {a : _} -> Var36 g a -> Tm36 g a
var36 = \ x, tm, var36, lam, app => var36 _ _ x

lam36 : {g : _} -> {a : _} -> {B : _} -> Tm36 (snoc36 g a) B -> Tm36 g (arr36 a B)
lam36 = \ t, tm, var36, lam36, app => lam36 _ _ _ (t tm var36 lam36 app)

app36 : {g:_}->{a:_}->{B:_} -> Tm36 g (arr36 a B) -> Tm36 g a -> Tm36 g B
app36 = \ t, u, tm, var36, lam36, app36 => app36 _ _ _ (t tm var36 lam36 app36) (u tm var36 lam36 app36)

v036 : {g:_}->{a:_} -> Tm36 (snoc36 g a) a
v036 = var36 vz36

v136 : {g:_}->{a:_}-> {B:_}-> Tm36 (snoc36 (snoc36 g a) B) a
v136 = var36 (vs36 vz36)

v236 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm36 (snoc36 (snoc36 (snoc36 g a) B) C) a
v236 = var36 (vs36 (vs36 vz36))

v336 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm36 (snoc36 (snoc36 (snoc36 (snoc36 g a) B) C) D) a
v336 = var36 (vs36 (vs36 (vs36 vz36)))

v436 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm36 (snoc36 (snoc36 (snoc36 (snoc36 (snoc36 g a) B) C) D) E) a
v436 = var36 (vs36 (vs36 (vs36 (vs36 vz36))))

test36 : {g:_}-> {a:_} -> Tm36 g (arr36 (arr36 a a) (arr36 a a))
test36  = lam36 (lam36 (app36 v136 (app36 v136 (app36 v136 (app36 v136 (app36 v136 (app36 v136 v036)))))))
Ty37 : Type
Ty37 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty37 : Ty37
empty37 = \ _, empty, _ => empty

arr37 : Ty37 -> Ty37 -> Ty37
arr37 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con37 : Type
Con37 = (Con37 : Type)
 ->(nil  : Con37)
 ->(snoc : Con37 -> Ty37 -> Con37)
 -> Con37

nil37 : Con37
nil37 = \ con, nil37, snoc => nil37

snoc37 : Con37 -> Ty37 -> Con37
snoc37 = \ g, a, con, nil37, snoc37 => snoc37 (g con nil37 snoc37) a

Var37 : Con37 -> Ty37 -> Type
Var37 = \ g, a =>
    (Var37 : Con37 -> Ty37 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var37 (snoc37 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var37 g a -> Var37 (snoc37 g b) a)
 -> Var37 g a

vz37 : {g : _}-> {a : _} -> Var37 (snoc37 g a) a
vz37 = \ var, vz37, vs => vz37 _ _

vs37 : {g : _} -> {B : _} -> {a : _} -> Var37 g a -> Var37 (snoc37 g B) a
vs37 = \ x, var, vz37, vs37 => vs37 _ _ _ (x var vz37 vs37)

Tm37 : Con37 -> Ty37 -> Type
Tm37 = \ g, a =>
    (Tm37    : Con37 -> Ty37 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var37 g a -> Tm37 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm37 (snoc37 g a) B -> Tm37 g (arr37 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm37 g (arr37 a B) -> Tm37 g a -> Tm37 g B)
 -> Tm37 g a

var37 : {g : _} -> {a : _} -> Var37 g a -> Tm37 g a
var37 = \ x, tm, var37, lam, app => var37 _ _ x

lam37 : {g : _} -> {a : _} -> {B : _} -> Tm37 (snoc37 g a) B -> Tm37 g (arr37 a B)
lam37 = \ t, tm, var37, lam37, app => lam37 _ _ _ (t tm var37 lam37 app)

app37 : {g:_}->{a:_}->{B:_} -> Tm37 g (arr37 a B) -> Tm37 g a -> Tm37 g B
app37 = \ t, u, tm, var37, lam37, app37 => app37 _ _ _ (t tm var37 lam37 app37) (u tm var37 lam37 app37)

v037 : {g:_}->{a:_} -> Tm37 (snoc37 g a) a
v037 = var37 vz37

v137 : {g:_}->{a:_}-> {B:_}-> Tm37 (snoc37 (snoc37 g a) B) a
v137 = var37 (vs37 vz37)

v237 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm37 (snoc37 (snoc37 (snoc37 g a) B) C) a
v237 = var37 (vs37 (vs37 vz37))

v337 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm37 (snoc37 (snoc37 (snoc37 (snoc37 g a) B) C) D) a
v337 = var37 (vs37 (vs37 (vs37 vz37)))

v437 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm37 (snoc37 (snoc37 (snoc37 (snoc37 (snoc37 g a) B) C) D) E) a
v437 = var37 (vs37 (vs37 (vs37 (vs37 vz37))))

test37 : {g:_}-> {a:_} -> Tm37 g (arr37 (arr37 a a) (arr37 a a))
test37  = lam37 (lam37 (app37 v137 (app37 v137 (app37 v137 (app37 v137 (app37 v137 (app37 v137 v037)))))))
Ty38 : Type
Ty38 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty38 : Ty38
empty38 = \ _, empty, _ => empty

arr38 : Ty38 -> Ty38 -> Ty38
arr38 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con38 : Type
Con38 = (Con38 : Type)
 ->(nil  : Con38)
 ->(snoc : Con38 -> Ty38 -> Con38)
 -> Con38

nil38 : Con38
nil38 = \ con, nil38, snoc => nil38

snoc38 : Con38 -> Ty38 -> Con38
snoc38 = \ g, a, con, nil38, snoc38 => snoc38 (g con nil38 snoc38) a

Var38 : Con38 -> Ty38 -> Type
Var38 = \ g, a =>
    (Var38 : Con38 -> Ty38 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var38 (snoc38 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var38 g a -> Var38 (snoc38 g b) a)
 -> Var38 g a

vz38 : {g : _}-> {a : _} -> Var38 (snoc38 g a) a
vz38 = \ var, vz38, vs => vz38 _ _

vs38 : {g : _} -> {B : _} -> {a : _} -> Var38 g a -> Var38 (snoc38 g B) a
vs38 = \ x, var, vz38, vs38 => vs38 _ _ _ (x var vz38 vs38)

Tm38 : Con38 -> Ty38 -> Type
Tm38 = \ g, a =>
    (Tm38    : Con38 -> Ty38 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var38 g a -> Tm38 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm38 (snoc38 g a) B -> Tm38 g (arr38 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm38 g (arr38 a B) -> Tm38 g a -> Tm38 g B)
 -> Tm38 g a

var38 : {g : _} -> {a : _} -> Var38 g a -> Tm38 g a
var38 = \ x, tm, var38, lam, app => var38 _ _ x

lam38 : {g : _} -> {a : _} -> {B : _} -> Tm38 (snoc38 g a) B -> Tm38 g (arr38 a B)
lam38 = \ t, tm, var38, lam38, app => lam38 _ _ _ (t tm var38 lam38 app)

app38 : {g:_}->{a:_}->{B:_} -> Tm38 g (arr38 a B) -> Tm38 g a -> Tm38 g B
app38 = \ t, u, tm, var38, lam38, app38 => app38 _ _ _ (t tm var38 lam38 app38) (u tm var38 lam38 app38)

v038 : {g:_}->{a:_} -> Tm38 (snoc38 g a) a
v038 = var38 vz38

v138 : {g:_}->{a:_}-> {B:_}-> Tm38 (snoc38 (snoc38 g a) B) a
v138 = var38 (vs38 vz38)

v238 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm38 (snoc38 (snoc38 (snoc38 g a) B) C) a
v238 = var38 (vs38 (vs38 vz38))

v338 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm38 (snoc38 (snoc38 (snoc38 (snoc38 g a) B) C) D) a
v338 = var38 (vs38 (vs38 (vs38 vz38)))

v438 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm38 (snoc38 (snoc38 (snoc38 (snoc38 (snoc38 g a) B) C) D) E) a
v438 = var38 (vs38 (vs38 (vs38 (vs38 vz38))))

test38 : {g:_}-> {a:_} -> Tm38 g (arr38 (arr38 a a) (arr38 a a))
test38  = lam38 (lam38 (app38 v138 (app38 v138 (app38 v138 (app38 v138 (app38 v138 (app38 v138 v038)))))))
Ty39 : Type
Ty39 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty39 : Ty39
empty39 = \ _, empty, _ => empty

arr39 : Ty39 -> Ty39 -> Ty39
arr39 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con39 : Type
Con39 = (Con39 : Type)
 ->(nil  : Con39)
 ->(snoc : Con39 -> Ty39 -> Con39)
 -> Con39

nil39 : Con39
nil39 = \ con, nil39, snoc => nil39

snoc39 : Con39 -> Ty39 -> Con39
snoc39 = \ g, a, con, nil39, snoc39 => snoc39 (g con nil39 snoc39) a

Var39 : Con39 -> Ty39 -> Type
Var39 = \ g, a =>
    (Var39 : Con39 -> Ty39 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var39 (snoc39 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var39 g a -> Var39 (snoc39 g b) a)
 -> Var39 g a

vz39 : {g : _}-> {a : _} -> Var39 (snoc39 g a) a
vz39 = \ var, vz39, vs => vz39 _ _

vs39 : {g : _} -> {B : _} -> {a : _} -> Var39 g a -> Var39 (snoc39 g B) a
vs39 = \ x, var, vz39, vs39 => vs39 _ _ _ (x var vz39 vs39)

Tm39 : Con39 -> Ty39 -> Type
Tm39 = \ g, a =>
    (Tm39    : Con39 -> Ty39 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var39 g a -> Tm39 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm39 (snoc39 g a) B -> Tm39 g (arr39 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm39 g (arr39 a B) -> Tm39 g a -> Tm39 g B)
 -> Tm39 g a

var39 : {g : _} -> {a : _} -> Var39 g a -> Tm39 g a
var39 = \ x, tm, var39, lam, app => var39 _ _ x

lam39 : {g : _} -> {a : _} -> {B : _} -> Tm39 (snoc39 g a) B -> Tm39 g (arr39 a B)
lam39 = \ t, tm, var39, lam39, app => lam39 _ _ _ (t tm var39 lam39 app)

app39 : {g:_}->{a:_}->{B:_} -> Tm39 g (arr39 a B) -> Tm39 g a -> Tm39 g B
app39 = \ t, u, tm, var39, lam39, app39 => app39 _ _ _ (t tm var39 lam39 app39) (u tm var39 lam39 app39)

v039 : {g:_}->{a:_} -> Tm39 (snoc39 g a) a
v039 = var39 vz39

v139 : {g:_}->{a:_}-> {B:_}-> Tm39 (snoc39 (snoc39 g a) B) a
v139 = var39 (vs39 vz39)

v239 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm39 (snoc39 (snoc39 (snoc39 g a) B) C) a
v239 = var39 (vs39 (vs39 vz39))

v339 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm39 (snoc39 (snoc39 (snoc39 (snoc39 g a) B) C) D) a
v339 = var39 (vs39 (vs39 (vs39 vz39)))

v439 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm39 (snoc39 (snoc39 (snoc39 (snoc39 (snoc39 g a) B) C) D) E) a
v439 = var39 (vs39 (vs39 (vs39 (vs39 vz39))))

test39 : {g:_}-> {a:_} -> Tm39 g (arr39 (arr39 a a) (arr39 a a))
test39  = lam39 (lam39 (app39 v139 (app39 v139 (app39 v139 (app39 v139 (app39 v139 (app39 v139 v039)))))))
Ty40 : Type
Ty40 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty40 : Ty40
empty40 = \ _, empty, _ => empty

arr40 : Ty40 -> Ty40 -> Ty40
arr40 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con40 : Type
Con40 = (Con40 : Type)
 ->(nil  : Con40)
 ->(snoc : Con40 -> Ty40 -> Con40)
 -> Con40

nil40 : Con40
nil40 = \ con, nil40, snoc => nil40

snoc40 : Con40 -> Ty40 -> Con40
snoc40 = \ g, a, con, nil40, snoc40 => snoc40 (g con nil40 snoc40) a

Var40 : Con40 -> Ty40 -> Type
Var40 = \ g, a =>
    (Var40 : Con40 -> Ty40 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var40 (snoc40 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var40 g a -> Var40 (snoc40 g b) a)
 -> Var40 g a

vz40 : {g : _}-> {a : _} -> Var40 (snoc40 g a) a
vz40 = \ var, vz40, vs => vz40 _ _

vs40 : {g : _} -> {B : _} -> {a : _} -> Var40 g a -> Var40 (snoc40 g B) a
vs40 = \ x, var, vz40, vs40 => vs40 _ _ _ (x var vz40 vs40)

Tm40 : Con40 -> Ty40 -> Type
Tm40 = \ g, a =>
    (Tm40    : Con40 -> Ty40 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var40 g a -> Tm40 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm40 (snoc40 g a) B -> Tm40 g (arr40 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm40 g (arr40 a B) -> Tm40 g a -> Tm40 g B)
 -> Tm40 g a

var40 : {g : _} -> {a : _} -> Var40 g a -> Tm40 g a
var40 = \ x, tm, var40, lam, app => var40 _ _ x

lam40 : {g : _} -> {a : _} -> {B : _} -> Tm40 (snoc40 g a) B -> Tm40 g (arr40 a B)
lam40 = \ t, tm, var40, lam40, app => lam40 _ _ _ (t tm var40 lam40 app)

app40 : {g:_}->{a:_}->{B:_} -> Tm40 g (arr40 a B) -> Tm40 g a -> Tm40 g B
app40 = \ t, u, tm, var40, lam40, app40 => app40 _ _ _ (t tm var40 lam40 app40) (u tm var40 lam40 app40)

v040 : {g:_}->{a:_} -> Tm40 (snoc40 g a) a
v040 = var40 vz40

v140 : {g:_}->{a:_}-> {B:_}-> Tm40 (snoc40 (snoc40 g a) B) a
v140 = var40 (vs40 vz40)

v240 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm40 (snoc40 (snoc40 (snoc40 g a) B) C) a
v240 = var40 (vs40 (vs40 vz40))

v340 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm40 (snoc40 (snoc40 (snoc40 (snoc40 g a) B) C) D) a
v340 = var40 (vs40 (vs40 (vs40 vz40)))

v440 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm40 (snoc40 (snoc40 (snoc40 (snoc40 (snoc40 g a) B) C) D) E) a
v440 = var40 (vs40 (vs40 (vs40 (vs40 vz40))))

test40 : {g:_}-> {a:_} -> Tm40 g (arr40 (arr40 a a) (arr40 a a))
test40  = lam40 (lam40 (app40 v140 (app40 v140 (app40 v140 (app40 v140 (app40 v140 (app40 v140 v040)))))))
Ty41 : Type
Ty41 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty41 : Ty41
empty41 = \ _, empty, _ => empty

arr41 : Ty41 -> Ty41 -> Ty41
arr41 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con41 : Type
Con41 = (Con41 : Type)
 ->(nil  : Con41)
 ->(snoc : Con41 -> Ty41 -> Con41)
 -> Con41

nil41 : Con41
nil41 = \ con, nil41, snoc => nil41

snoc41 : Con41 -> Ty41 -> Con41
snoc41 = \ g, a, con, nil41, snoc41 => snoc41 (g con nil41 snoc41) a

Var41 : Con41 -> Ty41 -> Type
Var41 = \ g, a =>
    (Var41 : Con41 -> Ty41 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var41 (snoc41 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var41 g a -> Var41 (snoc41 g b) a)
 -> Var41 g a

vz41 : {g : _}-> {a : _} -> Var41 (snoc41 g a) a
vz41 = \ var, vz41, vs => vz41 _ _

vs41 : {g : _} -> {B : _} -> {a : _} -> Var41 g a -> Var41 (snoc41 g B) a
vs41 = \ x, var, vz41, vs41 => vs41 _ _ _ (x var vz41 vs41)

Tm41 : Con41 -> Ty41 -> Type
Tm41 = \ g, a =>
    (Tm41    : Con41 -> Ty41 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var41 g a -> Tm41 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm41 (snoc41 g a) B -> Tm41 g (arr41 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm41 g (arr41 a B) -> Tm41 g a -> Tm41 g B)
 -> Tm41 g a

var41 : {g : _} -> {a : _} -> Var41 g a -> Tm41 g a
var41 = \ x, tm, var41, lam, app => var41 _ _ x

lam41 : {g : _} -> {a : _} -> {B : _} -> Tm41 (snoc41 g a) B -> Tm41 g (arr41 a B)
lam41 = \ t, tm, var41, lam41, app => lam41 _ _ _ (t tm var41 lam41 app)

app41 : {g:_}->{a:_}->{B:_} -> Tm41 g (arr41 a B) -> Tm41 g a -> Tm41 g B
app41 = \ t, u, tm, var41, lam41, app41 => app41 _ _ _ (t tm var41 lam41 app41) (u tm var41 lam41 app41)

v041 : {g:_}->{a:_} -> Tm41 (snoc41 g a) a
v041 = var41 vz41

v141 : {g:_}->{a:_}-> {B:_}-> Tm41 (snoc41 (snoc41 g a) B) a
v141 = var41 (vs41 vz41)

v241 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm41 (snoc41 (snoc41 (snoc41 g a) B) C) a
v241 = var41 (vs41 (vs41 vz41))

v341 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm41 (snoc41 (snoc41 (snoc41 (snoc41 g a) B) C) D) a
v341 = var41 (vs41 (vs41 (vs41 vz41)))

v441 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm41 (snoc41 (snoc41 (snoc41 (snoc41 (snoc41 g a) B) C) D) E) a
v441 = var41 (vs41 (vs41 (vs41 (vs41 vz41))))

test41 : {g:_}-> {a:_} -> Tm41 g (arr41 (arr41 a a) (arr41 a a))
test41  = lam41 (lam41 (app41 v141 (app41 v141 (app41 v141 (app41 v141 (app41 v141 (app41 v141 v041)))))))
Ty42 : Type
Ty42 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty42 : Ty42
empty42 = \ _, empty, _ => empty

arr42 : Ty42 -> Ty42 -> Ty42
arr42 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con42 : Type
Con42 = (Con42 : Type)
 ->(nil  : Con42)
 ->(snoc : Con42 -> Ty42 -> Con42)
 -> Con42

nil42 : Con42
nil42 = \ con, nil42, snoc => nil42

snoc42 : Con42 -> Ty42 -> Con42
snoc42 = \ g, a, con, nil42, snoc42 => snoc42 (g con nil42 snoc42) a

Var42 : Con42 -> Ty42 -> Type
Var42 = \ g, a =>
    (Var42 : Con42 -> Ty42 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var42 (snoc42 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var42 g a -> Var42 (snoc42 g b) a)
 -> Var42 g a

vz42 : {g : _}-> {a : _} -> Var42 (snoc42 g a) a
vz42 = \ var, vz42, vs => vz42 _ _

vs42 : {g : _} -> {B : _} -> {a : _} -> Var42 g a -> Var42 (snoc42 g B) a
vs42 = \ x, var, vz42, vs42 => vs42 _ _ _ (x var vz42 vs42)

Tm42 : Con42 -> Ty42 -> Type
Tm42 = \ g, a =>
    (Tm42    : Con42 -> Ty42 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var42 g a -> Tm42 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm42 (snoc42 g a) B -> Tm42 g (arr42 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm42 g (arr42 a B) -> Tm42 g a -> Tm42 g B)
 -> Tm42 g a

var42 : {g : _} -> {a : _} -> Var42 g a -> Tm42 g a
var42 = \ x, tm, var42, lam, app => var42 _ _ x

lam42 : {g : _} -> {a : _} -> {B : _} -> Tm42 (snoc42 g a) B -> Tm42 g (arr42 a B)
lam42 = \ t, tm, var42, lam42, app => lam42 _ _ _ (t tm var42 lam42 app)

app42 : {g:_}->{a:_}->{B:_} -> Tm42 g (arr42 a B) -> Tm42 g a -> Tm42 g B
app42 = \ t, u, tm, var42, lam42, app42 => app42 _ _ _ (t tm var42 lam42 app42) (u tm var42 lam42 app42)

v042 : {g:_}->{a:_} -> Tm42 (snoc42 g a) a
v042 = var42 vz42

v142 : {g:_}->{a:_}-> {B:_}-> Tm42 (snoc42 (snoc42 g a) B) a
v142 = var42 (vs42 vz42)

v242 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm42 (snoc42 (snoc42 (snoc42 g a) B) C) a
v242 = var42 (vs42 (vs42 vz42))

v342 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm42 (snoc42 (snoc42 (snoc42 (snoc42 g a) B) C) D) a
v342 = var42 (vs42 (vs42 (vs42 vz42)))

v442 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm42 (snoc42 (snoc42 (snoc42 (snoc42 (snoc42 g a) B) C) D) E) a
v442 = var42 (vs42 (vs42 (vs42 (vs42 vz42))))

test42 : {g:_}-> {a:_} -> Tm42 g (arr42 (arr42 a a) (arr42 a a))
test42  = lam42 (lam42 (app42 v142 (app42 v142 (app42 v142 (app42 v142 (app42 v142 (app42 v142 v042)))))))
Ty43 : Type
Ty43 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty43 : Ty43
empty43 = \ _, empty, _ => empty

arr43 : Ty43 -> Ty43 -> Ty43
arr43 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con43 : Type
Con43 = (Con43 : Type)
 ->(nil  : Con43)
 ->(snoc : Con43 -> Ty43 -> Con43)
 -> Con43

nil43 : Con43
nil43 = \ con, nil43, snoc => nil43

snoc43 : Con43 -> Ty43 -> Con43
snoc43 = \ g, a, con, nil43, snoc43 => snoc43 (g con nil43 snoc43) a

Var43 : Con43 -> Ty43 -> Type
Var43 = \ g, a =>
    (Var43 : Con43 -> Ty43 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var43 (snoc43 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var43 g a -> Var43 (snoc43 g b) a)
 -> Var43 g a

vz43 : {g : _}-> {a : _} -> Var43 (snoc43 g a) a
vz43 = \ var, vz43, vs => vz43 _ _

vs43 : {g : _} -> {B : _} -> {a : _} -> Var43 g a -> Var43 (snoc43 g B) a
vs43 = \ x, var, vz43, vs43 => vs43 _ _ _ (x var vz43 vs43)

Tm43 : Con43 -> Ty43 -> Type
Tm43 = \ g, a =>
    (Tm43    : Con43 -> Ty43 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var43 g a -> Tm43 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm43 (snoc43 g a) B -> Tm43 g (arr43 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm43 g (arr43 a B) -> Tm43 g a -> Tm43 g B)
 -> Tm43 g a

var43 : {g : _} -> {a : _} -> Var43 g a -> Tm43 g a
var43 = \ x, tm, var43, lam, app => var43 _ _ x

lam43 : {g : _} -> {a : _} -> {B : _} -> Tm43 (snoc43 g a) B -> Tm43 g (arr43 a B)
lam43 = \ t, tm, var43, lam43, app => lam43 _ _ _ (t tm var43 lam43 app)

app43 : {g:_}->{a:_}->{B:_} -> Tm43 g (arr43 a B) -> Tm43 g a -> Tm43 g B
app43 = \ t, u, tm, var43, lam43, app43 => app43 _ _ _ (t tm var43 lam43 app43) (u tm var43 lam43 app43)

v043 : {g:_}->{a:_} -> Tm43 (snoc43 g a) a
v043 = var43 vz43

v143 : {g:_}->{a:_}-> {B:_}-> Tm43 (snoc43 (snoc43 g a) B) a
v143 = var43 (vs43 vz43)

v243 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm43 (snoc43 (snoc43 (snoc43 g a) B) C) a
v243 = var43 (vs43 (vs43 vz43))

v343 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm43 (snoc43 (snoc43 (snoc43 (snoc43 g a) B) C) D) a
v343 = var43 (vs43 (vs43 (vs43 vz43)))

v443 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm43 (snoc43 (snoc43 (snoc43 (snoc43 (snoc43 g a) B) C) D) E) a
v443 = var43 (vs43 (vs43 (vs43 (vs43 vz43))))

test43 : {g:_}-> {a:_} -> Tm43 g (arr43 (arr43 a a) (arr43 a a))
test43  = lam43 (lam43 (app43 v143 (app43 v143 (app43 v143 (app43 v143 (app43 v143 (app43 v143 v043)))))))
Ty44 : Type
Ty44 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty44 : Ty44
empty44 = \ _, empty, _ => empty

arr44 : Ty44 -> Ty44 -> Ty44
arr44 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con44 : Type
Con44 = (Con44 : Type)
 ->(nil  : Con44)
 ->(snoc : Con44 -> Ty44 -> Con44)
 -> Con44

nil44 : Con44
nil44 = \ con, nil44, snoc => nil44

snoc44 : Con44 -> Ty44 -> Con44
snoc44 = \ g, a, con, nil44, snoc44 => snoc44 (g con nil44 snoc44) a

Var44 : Con44 -> Ty44 -> Type
Var44 = \ g, a =>
    (Var44 : Con44 -> Ty44 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var44 (snoc44 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var44 g a -> Var44 (snoc44 g b) a)
 -> Var44 g a

vz44 : {g : _}-> {a : _} -> Var44 (snoc44 g a) a
vz44 = \ var, vz44, vs => vz44 _ _

vs44 : {g : _} -> {B : _} -> {a : _} -> Var44 g a -> Var44 (snoc44 g B) a
vs44 = \ x, var, vz44, vs44 => vs44 _ _ _ (x var vz44 vs44)

Tm44 : Con44 -> Ty44 -> Type
Tm44 = \ g, a =>
    (Tm44    : Con44 -> Ty44 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var44 g a -> Tm44 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm44 (snoc44 g a) B -> Tm44 g (arr44 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm44 g (arr44 a B) -> Tm44 g a -> Tm44 g B)
 -> Tm44 g a

var44 : {g : _} -> {a : _} -> Var44 g a -> Tm44 g a
var44 = \ x, tm, var44, lam, app => var44 _ _ x

lam44 : {g : _} -> {a : _} -> {B : _} -> Tm44 (snoc44 g a) B -> Tm44 g (arr44 a B)
lam44 = \ t, tm, var44, lam44, app => lam44 _ _ _ (t tm var44 lam44 app)

app44 : {g:_}->{a:_}->{B:_} -> Tm44 g (arr44 a B) -> Tm44 g a -> Tm44 g B
app44 = \ t, u, tm, var44, lam44, app44 => app44 _ _ _ (t tm var44 lam44 app44) (u tm var44 lam44 app44)

v044 : {g:_}->{a:_} -> Tm44 (snoc44 g a) a
v044 = var44 vz44

v144 : {g:_}->{a:_}-> {B:_}-> Tm44 (snoc44 (snoc44 g a) B) a
v144 = var44 (vs44 vz44)

v244 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm44 (snoc44 (snoc44 (snoc44 g a) B) C) a
v244 = var44 (vs44 (vs44 vz44))

v344 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm44 (snoc44 (snoc44 (snoc44 (snoc44 g a) B) C) D) a
v344 = var44 (vs44 (vs44 (vs44 vz44)))

v444 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm44 (snoc44 (snoc44 (snoc44 (snoc44 (snoc44 g a) B) C) D) E) a
v444 = var44 (vs44 (vs44 (vs44 (vs44 vz44))))

test44 : {g:_}-> {a:_} -> Tm44 g (arr44 (arr44 a a) (arr44 a a))
test44  = lam44 (lam44 (app44 v144 (app44 v144 (app44 v144 (app44 v144 (app44 v144 (app44 v144 v044)))))))
Ty45 : Type
Ty45 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty45 : Ty45
empty45 = \ _, empty, _ => empty

arr45 : Ty45 -> Ty45 -> Ty45
arr45 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con45 : Type
Con45 = (Con45 : Type)
 ->(nil  : Con45)
 ->(snoc : Con45 -> Ty45 -> Con45)
 -> Con45

nil45 : Con45
nil45 = \ con, nil45, snoc => nil45

snoc45 : Con45 -> Ty45 -> Con45
snoc45 = \ g, a, con, nil45, snoc45 => snoc45 (g con nil45 snoc45) a

Var45 : Con45 -> Ty45 -> Type
Var45 = \ g, a =>
    (Var45 : Con45 -> Ty45 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var45 (snoc45 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var45 g a -> Var45 (snoc45 g b) a)
 -> Var45 g a

vz45 : {g : _}-> {a : _} -> Var45 (snoc45 g a) a
vz45 = \ var, vz45, vs => vz45 _ _

vs45 : {g : _} -> {B : _} -> {a : _} -> Var45 g a -> Var45 (snoc45 g B) a
vs45 = \ x, var, vz45, vs45 => vs45 _ _ _ (x var vz45 vs45)

Tm45 : Con45 -> Ty45 -> Type
Tm45 = \ g, a =>
    (Tm45    : Con45 -> Ty45 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var45 g a -> Tm45 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm45 (snoc45 g a) B -> Tm45 g (arr45 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm45 g (arr45 a B) -> Tm45 g a -> Tm45 g B)
 -> Tm45 g a

var45 : {g : _} -> {a : _} -> Var45 g a -> Tm45 g a
var45 = \ x, tm, var45, lam, app => var45 _ _ x

lam45 : {g : _} -> {a : _} -> {B : _} -> Tm45 (snoc45 g a) B -> Tm45 g (arr45 a B)
lam45 = \ t, tm, var45, lam45, app => lam45 _ _ _ (t tm var45 lam45 app)

app45 : {g:_}->{a:_}->{B:_} -> Tm45 g (arr45 a B) -> Tm45 g a -> Tm45 g B
app45 = \ t, u, tm, var45, lam45, app45 => app45 _ _ _ (t tm var45 lam45 app45) (u tm var45 lam45 app45)

v045 : {g:_}->{a:_} -> Tm45 (snoc45 g a) a
v045 = var45 vz45

v145 : {g:_}->{a:_}-> {B:_}-> Tm45 (snoc45 (snoc45 g a) B) a
v145 = var45 (vs45 vz45)

v245 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm45 (snoc45 (snoc45 (snoc45 g a) B) C) a
v245 = var45 (vs45 (vs45 vz45))

v345 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm45 (snoc45 (snoc45 (snoc45 (snoc45 g a) B) C) D) a
v345 = var45 (vs45 (vs45 (vs45 vz45)))

v445 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm45 (snoc45 (snoc45 (snoc45 (snoc45 (snoc45 g a) B) C) D) E) a
v445 = var45 (vs45 (vs45 (vs45 (vs45 vz45))))

test45 : {g:_}-> {a:_} -> Tm45 g (arr45 (arr45 a a) (arr45 a a))
test45  = lam45 (lam45 (app45 v145 (app45 v145 (app45 v145 (app45 v145 (app45 v145 (app45 v145 v045)))))))
Ty46 : Type
Ty46 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty46 : Ty46
empty46 = \ _, empty, _ => empty

arr46 : Ty46 -> Ty46 -> Ty46
arr46 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con46 : Type
Con46 = (Con46 : Type)
 ->(nil  : Con46)
 ->(snoc : Con46 -> Ty46 -> Con46)
 -> Con46

nil46 : Con46
nil46 = \ con, nil46, snoc => nil46

snoc46 : Con46 -> Ty46 -> Con46
snoc46 = \ g, a, con, nil46, snoc46 => snoc46 (g con nil46 snoc46) a

Var46 : Con46 -> Ty46 -> Type
Var46 = \ g, a =>
    (Var46 : Con46 -> Ty46 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var46 (snoc46 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var46 g a -> Var46 (snoc46 g b) a)
 -> Var46 g a

vz46 : {g : _}-> {a : _} -> Var46 (snoc46 g a) a
vz46 = \ var, vz46, vs => vz46 _ _

vs46 : {g : _} -> {B : _} -> {a : _} -> Var46 g a -> Var46 (snoc46 g B) a
vs46 = \ x, var, vz46, vs46 => vs46 _ _ _ (x var vz46 vs46)

Tm46 : Con46 -> Ty46 -> Type
Tm46 = \ g, a =>
    (Tm46    : Con46 -> Ty46 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var46 g a -> Tm46 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm46 (snoc46 g a) B -> Tm46 g (arr46 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm46 g (arr46 a B) -> Tm46 g a -> Tm46 g B)
 -> Tm46 g a

var46 : {g : _} -> {a : _} -> Var46 g a -> Tm46 g a
var46 = \ x, tm, var46, lam, app => var46 _ _ x

lam46 : {g : _} -> {a : _} -> {B : _} -> Tm46 (snoc46 g a) B -> Tm46 g (arr46 a B)
lam46 = \ t, tm, var46, lam46, app => lam46 _ _ _ (t tm var46 lam46 app)

app46 : {g:_}->{a:_}->{B:_} -> Tm46 g (arr46 a B) -> Tm46 g a -> Tm46 g B
app46 = \ t, u, tm, var46, lam46, app46 => app46 _ _ _ (t tm var46 lam46 app46) (u tm var46 lam46 app46)

v046 : {g:_}->{a:_} -> Tm46 (snoc46 g a) a
v046 = var46 vz46

v146 : {g:_}->{a:_}-> {B:_}-> Tm46 (snoc46 (snoc46 g a) B) a
v146 = var46 (vs46 vz46)

v246 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm46 (snoc46 (snoc46 (snoc46 g a) B) C) a
v246 = var46 (vs46 (vs46 vz46))

v346 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm46 (snoc46 (snoc46 (snoc46 (snoc46 g a) B) C) D) a
v346 = var46 (vs46 (vs46 (vs46 vz46)))

v446 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm46 (snoc46 (snoc46 (snoc46 (snoc46 (snoc46 g a) B) C) D) E) a
v446 = var46 (vs46 (vs46 (vs46 (vs46 vz46))))

test46 : {g:_}-> {a:_} -> Tm46 g (arr46 (arr46 a a) (arr46 a a))
test46  = lam46 (lam46 (app46 v146 (app46 v146 (app46 v146 (app46 v146 (app46 v146 (app46 v146 v046)))))))
Ty47 : Type
Ty47 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty47 : Ty47
empty47 = \ _, empty, _ => empty

arr47 : Ty47 -> Ty47 -> Ty47
arr47 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con47 : Type
Con47 = (Con47 : Type)
 ->(nil  : Con47)
 ->(snoc : Con47 -> Ty47 -> Con47)
 -> Con47

nil47 : Con47
nil47 = \ con, nil47, snoc => nil47

snoc47 : Con47 -> Ty47 -> Con47
snoc47 = \ g, a, con, nil47, snoc47 => snoc47 (g con nil47 snoc47) a

Var47 : Con47 -> Ty47 -> Type
Var47 = \ g, a =>
    (Var47 : Con47 -> Ty47 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var47 (snoc47 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var47 g a -> Var47 (snoc47 g b) a)
 -> Var47 g a

vz47 : {g : _}-> {a : _} -> Var47 (snoc47 g a) a
vz47 = \ var, vz47, vs => vz47 _ _

vs47 : {g : _} -> {B : _} -> {a : _} -> Var47 g a -> Var47 (snoc47 g B) a
vs47 = \ x, var, vz47, vs47 => vs47 _ _ _ (x var vz47 vs47)

Tm47 : Con47 -> Ty47 -> Type
Tm47 = \ g, a =>
    (Tm47    : Con47 -> Ty47 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var47 g a -> Tm47 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm47 (snoc47 g a) B -> Tm47 g (arr47 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm47 g (arr47 a B) -> Tm47 g a -> Tm47 g B)
 -> Tm47 g a

var47 : {g : _} -> {a : _} -> Var47 g a -> Tm47 g a
var47 = \ x, tm, var47, lam, app => var47 _ _ x

lam47 : {g : _} -> {a : _} -> {B : _} -> Tm47 (snoc47 g a) B -> Tm47 g (arr47 a B)
lam47 = \ t, tm, var47, lam47, app => lam47 _ _ _ (t tm var47 lam47 app)

app47 : {g:_}->{a:_}->{B:_} -> Tm47 g (arr47 a B) -> Tm47 g a -> Tm47 g B
app47 = \ t, u, tm, var47, lam47, app47 => app47 _ _ _ (t tm var47 lam47 app47) (u tm var47 lam47 app47)

v047 : {g:_}->{a:_} -> Tm47 (snoc47 g a) a
v047 = var47 vz47

v147 : {g:_}->{a:_}-> {B:_}-> Tm47 (snoc47 (snoc47 g a) B) a
v147 = var47 (vs47 vz47)

v247 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm47 (snoc47 (snoc47 (snoc47 g a) B) C) a
v247 = var47 (vs47 (vs47 vz47))

v347 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm47 (snoc47 (snoc47 (snoc47 (snoc47 g a) B) C) D) a
v347 = var47 (vs47 (vs47 (vs47 vz47)))

v447 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm47 (snoc47 (snoc47 (snoc47 (snoc47 (snoc47 g a) B) C) D) E) a
v447 = var47 (vs47 (vs47 (vs47 (vs47 vz47))))

test47 : {g:_}-> {a:_} -> Tm47 g (arr47 (arr47 a a) (arr47 a a))
test47  = lam47 (lam47 (app47 v147 (app47 v147 (app47 v147 (app47 v147 (app47 v147 (app47 v147 v047)))))))
Ty48 : Type
Ty48 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty48 : Ty48
empty48 = \ _, empty, _ => empty

arr48 : Ty48 -> Ty48 -> Ty48
arr48 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con48 : Type
Con48 = (Con48 : Type)
 ->(nil  : Con48)
 ->(snoc : Con48 -> Ty48 -> Con48)
 -> Con48

nil48 : Con48
nil48 = \ con, nil48, snoc => nil48

snoc48 : Con48 -> Ty48 -> Con48
snoc48 = \ g, a, con, nil48, snoc48 => snoc48 (g con nil48 snoc48) a

Var48 : Con48 -> Ty48 -> Type
Var48 = \ g, a =>
    (Var48 : Con48 -> Ty48 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var48 (snoc48 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var48 g a -> Var48 (snoc48 g b) a)
 -> Var48 g a

vz48 : {g : _}-> {a : _} -> Var48 (snoc48 g a) a
vz48 = \ var, vz48, vs => vz48 _ _

vs48 : {g : _} -> {B : _} -> {a : _} -> Var48 g a -> Var48 (snoc48 g B) a
vs48 = \ x, var, vz48, vs48 => vs48 _ _ _ (x var vz48 vs48)

Tm48 : Con48 -> Ty48 -> Type
Tm48 = \ g, a =>
    (Tm48    : Con48 -> Ty48 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var48 g a -> Tm48 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm48 (snoc48 g a) B -> Tm48 g (arr48 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm48 g (arr48 a B) -> Tm48 g a -> Tm48 g B)
 -> Tm48 g a

var48 : {g : _} -> {a : _} -> Var48 g a -> Tm48 g a
var48 = \ x, tm, var48, lam, app => var48 _ _ x

lam48 : {g : _} -> {a : _} -> {B : _} -> Tm48 (snoc48 g a) B -> Tm48 g (arr48 a B)
lam48 = \ t, tm, var48, lam48, app => lam48 _ _ _ (t tm var48 lam48 app)

app48 : {g:_}->{a:_}->{B:_} -> Tm48 g (arr48 a B) -> Tm48 g a -> Tm48 g B
app48 = \ t, u, tm, var48, lam48, app48 => app48 _ _ _ (t tm var48 lam48 app48) (u tm var48 lam48 app48)

v048 : {g:_}->{a:_} -> Tm48 (snoc48 g a) a
v048 = var48 vz48

v148 : {g:_}->{a:_}-> {B:_}-> Tm48 (snoc48 (snoc48 g a) B) a
v148 = var48 (vs48 vz48)

v248 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm48 (snoc48 (snoc48 (snoc48 g a) B) C) a
v248 = var48 (vs48 (vs48 vz48))

v348 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm48 (snoc48 (snoc48 (snoc48 (snoc48 g a) B) C) D) a
v348 = var48 (vs48 (vs48 (vs48 vz48)))

v448 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm48 (snoc48 (snoc48 (snoc48 (snoc48 (snoc48 g a) B) C) D) E) a
v448 = var48 (vs48 (vs48 (vs48 (vs48 vz48))))

test48 : {g:_}-> {a:_} -> Tm48 g (arr48 (arr48 a a) (arr48 a a))
test48  = lam48 (lam48 (app48 v148 (app48 v148 (app48 v148 (app48 v148 (app48 v148 (app48 v148 v048)))))))
Ty49 : Type
Ty49 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty49 : Ty49
empty49 = \ _, empty, _ => empty

arr49 : Ty49 -> Ty49 -> Ty49
arr49 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con49 : Type
Con49 = (Con49 : Type)
 ->(nil  : Con49)
 ->(snoc : Con49 -> Ty49 -> Con49)
 -> Con49

nil49 : Con49
nil49 = \ con, nil49, snoc => nil49

snoc49 : Con49 -> Ty49 -> Con49
snoc49 = \ g, a, con, nil49, snoc49 => snoc49 (g con nil49 snoc49) a

Var49 : Con49 -> Ty49 -> Type
Var49 = \ g, a =>
    (Var49 : Con49 -> Ty49 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var49 (snoc49 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var49 g a -> Var49 (snoc49 g b) a)
 -> Var49 g a

vz49 : {g : _}-> {a : _} -> Var49 (snoc49 g a) a
vz49 = \ var, vz49, vs => vz49 _ _

vs49 : {g : _} -> {B : _} -> {a : _} -> Var49 g a -> Var49 (snoc49 g B) a
vs49 = \ x, var, vz49, vs49 => vs49 _ _ _ (x var vz49 vs49)

Tm49 : Con49 -> Ty49 -> Type
Tm49 = \ g, a =>
    (Tm49    : Con49 -> Ty49 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var49 g a -> Tm49 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm49 (snoc49 g a) B -> Tm49 g (arr49 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm49 g (arr49 a B) -> Tm49 g a -> Tm49 g B)
 -> Tm49 g a

var49 : {g : _} -> {a : _} -> Var49 g a -> Tm49 g a
var49 = \ x, tm, var49, lam, app => var49 _ _ x

lam49 : {g : _} -> {a : _} -> {B : _} -> Tm49 (snoc49 g a) B -> Tm49 g (arr49 a B)
lam49 = \ t, tm, var49, lam49, app => lam49 _ _ _ (t tm var49 lam49 app)

app49 : {g:_}->{a:_}->{B:_} -> Tm49 g (arr49 a B) -> Tm49 g a -> Tm49 g B
app49 = \ t, u, tm, var49, lam49, app49 => app49 _ _ _ (t tm var49 lam49 app49) (u tm var49 lam49 app49)

v049 : {g:_}->{a:_} -> Tm49 (snoc49 g a) a
v049 = var49 vz49

v149 : {g:_}->{a:_}-> {B:_}-> Tm49 (snoc49 (snoc49 g a) B) a
v149 = var49 (vs49 vz49)

v249 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm49 (snoc49 (snoc49 (snoc49 g a) B) C) a
v249 = var49 (vs49 (vs49 vz49))

v349 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm49 (snoc49 (snoc49 (snoc49 (snoc49 g a) B) C) D) a
v349 = var49 (vs49 (vs49 (vs49 vz49)))

v449 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm49 (snoc49 (snoc49 (snoc49 (snoc49 (snoc49 g a) B) C) D) E) a
v449 = var49 (vs49 (vs49 (vs49 (vs49 vz49))))

test49 : {g:_}-> {a:_} -> Tm49 g (arr49 (arr49 a a) (arr49 a a))
test49  = lam49 (lam49 (app49 v149 (app49 v149 (app49 v149 (app49 v149 (app49 v149 (app49 v149 v049)))))))
Ty50 : Type
Ty50 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty50 : Ty50
empty50 = \ _, empty, _ => empty

arr50 : Ty50 -> Ty50 -> Ty50
arr50 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con50 : Type
Con50 = (Con50 : Type)
 ->(nil  : Con50)
 ->(snoc : Con50 -> Ty50 -> Con50)
 -> Con50

nil50 : Con50
nil50 = \ con, nil50, snoc => nil50

snoc50 : Con50 -> Ty50 -> Con50
snoc50 = \ g, a, con, nil50, snoc50 => snoc50 (g con nil50 snoc50) a

Var50 : Con50 -> Ty50 -> Type
Var50 = \ g, a =>
    (Var50 : Con50 -> Ty50 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var50 (snoc50 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var50 g a -> Var50 (snoc50 g b) a)
 -> Var50 g a

vz50 : {g : _}-> {a : _} -> Var50 (snoc50 g a) a
vz50 = \ var, vz50, vs => vz50 _ _

vs50 : {g : _} -> {B : _} -> {a : _} -> Var50 g a -> Var50 (snoc50 g B) a
vs50 = \ x, var, vz50, vs50 => vs50 _ _ _ (x var vz50 vs50)

Tm50 : Con50 -> Ty50 -> Type
Tm50 = \ g, a =>
    (Tm50    : Con50 -> Ty50 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var50 g a -> Tm50 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm50 (snoc50 g a) B -> Tm50 g (arr50 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm50 g (arr50 a B) -> Tm50 g a -> Tm50 g B)
 -> Tm50 g a

var50 : {g : _} -> {a : _} -> Var50 g a -> Tm50 g a
var50 = \ x, tm, var50, lam, app => var50 _ _ x

lam50 : {g : _} -> {a : _} -> {B : _} -> Tm50 (snoc50 g a) B -> Tm50 g (arr50 a B)
lam50 = \ t, tm, var50, lam50, app => lam50 _ _ _ (t tm var50 lam50 app)

app50 : {g:_}->{a:_}->{B:_} -> Tm50 g (arr50 a B) -> Tm50 g a -> Tm50 g B
app50 = \ t, u, tm, var50, lam50, app50 => app50 _ _ _ (t tm var50 lam50 app50) (u tm var50 lam50 app50)

v050 : {g:_}->{a:_} -> Tm50 (snoc50 g a) a
v050 = var50 vz50

v150 : {g:_}->{a:_}-> {B:_}-> Tm50 (snoc50 (snoc50 g a) B) a
v150 = var50 (vs50 vz50)

v250 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm50 (snoc50 (snoc50 (snoc50 g a) B) C) a
v250 = var50 (vs50 (vs50 vz50))

v350 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm50 (snoc50 (snoc50 (snoc50 (snoc50 g a) B) C) D) a
v350 = var50 (vs50 (vs50 (vs50 vz50)))

v450 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm50 (snoc50 (snoc50 (snoc50 (snoc50 (snoc50 g a) B) C) D) E) a
v450 = var50 (vs50 (vs50 (vs50 (vs50 vz50))))

test50 : {g:_}-> {a:_} -> Tm50 g (arr50 (arr50 a a) (arr50 a a))
test50  = lam50 (lam50 (app50 v150 (app50 v150 (app50 v150 (app50 v150 (app50 v150 (app50 v150 v050)))))))
Ty51 : Type
Ty51 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty51 : Ty51
empty51 = \ _, empty, _ => empty

arr51 : Ty51 -> Ty51 -> Ty51
arr51 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con51 : Type
Con51 = (Con51 : Type)
 ->(nil  : Con51)
 ->(snoc : Con51 -> Ty51 -> Con51)
 -> Con51

nil51 : Con51
nil51 = \ con, nil51, snoc => nil51

snoc51 : Con51 -> Ty51 -> Con51
snoc51 = \ g, a, con, nil51, snoc51 => snoc51 (g con nil51 snoc51) a

Var51 : Con51 -> Ty51 -> Type
Var51 = \ g, a =>
    (Var51 : Con51 -> Ty51 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var51 (snoc51 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var51 g a -> Var51 (snoc51 g b) a)
 -> Var51 g a

vz51 : {g : _}-> {a : _} -> Var51 (snoc51 g a) a
vz51 = \ var, vz51, vs => vz51 _ _

vs51 : {g : _} -> {B : _} -> {a : _} -> Var51 g a -> Var51 (snoc51 g B) a
vs51 = \ x, var, vz51, vs51 => vs51 _ _ _ (x var vz51 vs51)

Tm51 : Con51 -> Ty51 -> Type
Tm51 = \ g, a =>
    (Tm51    : Con51 -> Ty51 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var51 g a -> Tm51 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm51 (snoc51 g a) B -> Tm51 g (arr51 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm51 g (arr51 a B) -> Tm51 g a -> Tm51 g B)
 -> Tm51 g a

var51 : {g : _} -> {a : _} -> Var51 g a -> Tm51 g a
var51 = \ x, tm, var51, lam, app => var51 _ _ x

lam51 : {g : _} -> {a : _} -> {B : _} -> Tm51 (snoc51 g a) B -> Tm51 g (arr51 a B)
lam51 = \ t, tm, var51, lam51, app => lam51 _ _ _ (t tm var51 lam51 app)

app51 : {g:_}->{a:_}->{B:_} -> Tm51 g (arr51 a B) -> Tm51 g a -> Tm51 g B
app51 = \ t, u, tm, var51, lam51, app51 => app51 _ _ _ (t tm var51 lam51 app51) (u tm var51 lam51 app51)

v051 : {g:_}->{a:_} -> Tm51 (snoc51 g a) a
v051 = var51 vz51

v151 : {g:_}->{a:_}-> {B:_}-> Tm51 (snoc51 (snoc51 g a) B) a
v151 = var51 (vs51 vz51)

v251 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm51 (snoc51 (snoc51 (snoc51 g a) B) C) a
v251 = var51 (vs51 (vs51 vz51))

v351 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm51 (snoc51 (snoc51 (snoc51 (snoc51 g a) B) C) D) a
v351 = var51 (vs51 (vs51 (vs51 vz51)))

v451 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm51 (snoc51 (snoc51 (snoc51 (snoc51 (snoc51 g a) B) C) D) E) a
v451 = var51 (vs51 (vs51 (vs51 (vs51 vz51))))

test51 : {g:_}-> {a:_} -> Tm51 g (arr51 (arr51 a a) (arr51 a a))
test51  = lam51 (lam51 (app51 v151 (app51 v151 (app51 v151 (app51 v151 (app51 v151 (app51 v151 v051)))))))
Ty52 : Type
Ty52 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty52 : Ty52
empty52 = \ _, empty, _ => empty

arr52 : Ty52 -> Ty52 -> Ty52
arr52 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con52 : Type
Con52 = (Con52 : Type)
 ->(nil  : Con52)
 ->(snoc : Con52 -> Ty52 -> Con52)
 -> Con52

nil52 : Con52
nil52 = \ con, nil52, snoc => nil52

snoc52 : Con52 -> Ty52 -> Con52
snoc52 = \ g, a, con, nil52, snoc52 => snoc52 (g con nil52 snoc52) a

Var52 : Con52 -> Ty52 -> Type
Var52 = \ g, a =>
    (Var52 : Con52 -> Ty52 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var52 (snoc52 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var52 g a -> Var52 (snoc52 g b) a)
 -> Var52 g a

vz52 : {g : _}-> {a : _} -> Var52 (snoc52 g a) a
vz52 = \ var, vz52, vs => vz52 _ _

vs52 : {g : _} -> {B : _} -> {a : _} -> Var52 g a -> Var52 (snoc52 g B) a
vs52 = \ x, var, vz52, vs52 => vs52 _ _ _ (x var vz52 vs52)

Tm52 : Con52 -> Ty52 -> Type
Tm52 = \ g, a =>
    (Tm52    : Con52 -> Ty52 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var52 g a -> Tm52 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm52 (snoc52 g a) B -> Tm52 g (arr52 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm52 g (arr52 a B) -> Tm52 g a -> Tm52 g B)
 -> Tm52 g a

var52 : {g : _} -> {a : _} -> Var52 g a -> Tm52 g a
var52 = \ x, tm, var52, lam, app => var52 _ _ x

lam52 : {g : _} -> {a : _} -> {B : _} -> Tm52 (snoc52 g a) B -> Tm52 g (arr52 a B)
lam52 = \ t, tm, var52, lam52, app => lam52 _ _ _ (t tm var52 lam52 app)

app52 : {g:_}->{a:_}->{B:_} -> Tm52 g (arr52 a B) -> Tm52 g a -> Tm52 g B
app52 = \ t, u, tm, var52, lam52, app52 => app52 _ _ _ (t tm var52 lam52 app52) (u tm var52 lam52 app52)

v052 : {g:_}->{a:_} -> Tm52 (snoc52 g a) a
v052 = var52 vz52

v152 : {g:_}->{a:_}-> {B:_}-> Tm52 (snoc52 (snoc52 g a) B) a
v152 = var52 (vs52 vz52)

v252 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm52 (snoc52 (snoc52 (snoc52 g a) B) C) a
v252 = var52 (vs52 (vs52 vz52))

v352 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm52 (snoc52 (snoc52 (snoc52 (snoc52 g a) B) C) D) a
v352 = var52 (vs52 (vs52 (vs52 vz52)))

v452 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm52 (snoc52 (snoc52 (snoc52 (snoc52 (snoc52 g a) B) C) D) E) a
v452 = var52 (vs52 (vs52 (vs52 (vs52 vz52))))

test52 : {g:_}-> {a:_} -> Tm52 g (arr52 (arr52 a a) (arr52 a a))
test52  = lam52 (lam52 (app52 v152 (app52 v152 (app52 v152 (app52 v152 (app52 v152 (app52 v152 v052)))))))
Ty53 : Type
Ty53 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty53 : Ty53
empty53 = \ _, empty, _ => empty

arr53 : Ty53 -> Ty53 -> Ty53
arr53 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con53 : Type
Con53 = (Con53 : Type)
 ->(nil  : Con53)
 ->(snoc : Con53 -> Ty53 -> Con53)
 -> Con53

nil53 : Con53
nil53 = \ con, nil53, snoc => nil53

snoc53 : Con53 -> Ty53 -> Con53
snoc53 = \ g, a, con, nil53, snoc53 => snoc53 (g con nil53 snoc53) a

Var53 : Con53 -> Ty53 -> Type
Var53 = \ g, a =>
    (Var53 : Con53 -> Ty53 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var53 (snoc53 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var53 g a -> Var53 (snoc53 g b) a)
 -> Var53 g a

vz53 : {g : _}-> {a : _} -> Var53 (snoc53 g a) a
vz53 = \ var, vz53, vs => vz53 _ _

vs53 : {g : _} -> {B : _} -> {a : _} -> Var53 g a -> Var53 (snoc53 g B) a
vs53 = \ x, var, vz53, vs53 => vs53 _ _ _ (x var vz53 vs53)

Tm53 : Con53 -> Ty53 -> Type
Tm53 = \ g, a =>
    (Tm53    : Con53 -> Ty53 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var53 g a -> Tm53 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm53 (snoc53 g a) B -> Tm53 g (arr53 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm53 g (arr53 a B) -> Tm53 g a -> Tm53 g B)
 -> Tm53 g a

var53 : {g : _} -> {a : _} -> Var53 g a -> Tm53 g a
var53 = \ x, tm, var53, lam, app => var53 _ _ x

lam53 : {g : _} -> {a : _} -> {B : _} -> Tm53 (snoc53 g a) B -> Tm53 g (arr53 a B)
lam53 = \ t, tm, var53, lam53, app => lam53 _ _ _ (t tm var53 lam53 app)

app53 : {g:_}->{a:_}->{B:_} -> Tm53 g (arr53 a B) -> Tm53 g a -> Tm53 g B
app53 = \ t, u, tm, var53, lam53, app53 => app53 _ _ _ (t tm var53 lam53 app53) (u tm var53 lam53 app53)

v053 : {g:_}->{a:_} -> Tm53 (snoc53 g a) a
v053 = var53 vz53

v153 : {g:_}->{a:_}-> {B:_}-> Tm53 (snoc53 (snoc53 g a) B) a
v153 = var53 (vs53 vz53)

v253 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm53 (snoc53 (snoc53 (snoc53 g a) B) C) a
v253 = var53 (vs53 (vs53 vz53))

v353 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm53 (snoc53 (snoc53 (snoc53 (snoc53 g a) B) C) D) a
v353 = var53 (vs53 (vs53 (vs53 vz53)))

v453 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm53 (snoc53 (snoc53 (snoc53 (snoc53 (snoc53 g a) B) C) D) E) a
v453 = var53 (vs53 (vs53 (vs53 (vs53 vz53))))

test53 : {g:_}-> {a:_} -> Tm53 g (arr53 (arr53 a a) (arr53 a a))
test53  = lam53 (lam53 (app53 v153 (app53 v153 (app53 v153 (app53 v153 (app53 v153 (app53 v153 v053)))))))
Ty54 : Type
Ty54 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty54 : Ty54
empty54 = \ _, empty, _ => empty

arr54 : Ty54 -> Ty54 -> Ty54
arr54 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con54 : Type
Con54 = (Con54 : Type)
 ->(nil  : Con54)
 ->(snoc : Con54 -> Ty54 -> Con54)
 -> Con54

nil54 : Con54
nil54 = \ con, nil54, snoc => nil54

snoc54 : Con54 -> Ty54 -> Con54
snoc54 = \ g, a, con, nil54, snoc54 => snoc54 (g con nil54 snoc54) a

Var54 : Con54 -> Ty54 -> Type
Var54 = \ g, a =>
    (Var54 : Con54 -> Ty54 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var54 (snoc54 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var54 g a -> Var54 (snoc54 g b) a)
 -> Var54 g a

vz54 : {g : _}-> {a : _} -> Var54 (snoc54 g a) a
vz54 = \ var, vz54, vs => vz54 _ _

vs54 : {g : _} -> {B : _} -> {a : _} -> Var54 g a -> Var54 (snoc54 g B) a
vs54 = \ x, var, vz54, vs54 => vs54 _ _ _ (x var vz54 vs54)

Tm54 : Con54 -> Ty54 -> Type
Tm54 = \ g, a =>
    (Tm54    : Con54 -> Ty54 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var54 g a -> Tm54 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm54 (snoc54 g a) B -> Tm54 g (arr54 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm54 g (arr54 a B) -> Tm54 g a -> Tm54 g B)
 -> Tm54 g a

var54 : {g : _} -> {a : _} -> Var54 g a -> Tm54 g a
var54 = \ x, tm, var54, lam, app => var54 _ _ x

lam54 : {g : _} -> {a : _} -> {B : _} -> Tm54 (snoc54 g a) B -> Tm54 g (arr54 a B)
lam54 = \ t, tm, var54, lam54, app => lam54 _ _ _ (t tm var54 lam54 app)

app54 : {g:_}->{a:_}->{B:_} -> Tm54 g (arr54 a B) -> Tm54 g a -> Tm54 g B
app54 = \ t, u, tm, var54, lam54, app54 => app54 _ _ _ (t tm var54 lam54 app54) (u tm var54 lam54 app54)

v054 : {g:_}->{a:_} -> Tm54 (snoc54 g a) a
v054 = var54 vz54

v154 : {g:_}->{a:_}-> {B:_}-> Tm54 (snoc54 (snoc54 g a) B) a
v154 = var54 (vs54 vz54)

v254 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm54 (snoc54 (snoc54 (snoc54 g a) B) C) a
v254 = var54 (vs54 (vs54 vz54))

v354 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm54 (snoc54 (snoc54 (snoc54 (snoc54 g a) B) C) D) a
v354 = var54 (vs54 (vs54 (vs54 vz54)))

v454 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm54 (snoc54 (snoc54 (snoc54 (snoc54 (snoc54 g a) B) C) D) E) a
v454 = var54 (vs54 (vs54 (vs54 (vs54 vz54))))

test54 : {g:_}-> {a:_} -> Tm54 g (arr54 (arr54 a a) (arr54 a a))
test54  = lam54 (lam54 (app54 v154 (app54 v154 (app54 v154 (app54 v154 (app54 v154 (app54 v154 v054)))))))
Ty55 : Type
Ty55 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty55 : Ty55
empty55 = \ _, empty, _ => empty

arr55 : Ty55 -> Ty55 -> Ty55
arr55 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con55 : Type
Con55 = (Con55 : Type)
 ->(nil  : Con55)
 ->(snoc : Con55 -> Ty55 -> Con55)
 -> Con55

nil55 : Con55
nil55 = \ con, nil55, snoc => nil55

snoc55 : Con55 -> Ty55 -> Con55
snoc55 = \ g, a, con, nil55, snoc55 => snoc55 (g con nil55 snoc55) a

Var55 : Con55 -> Ty55 -> Type
Var55 = \ g, a =>
    (Var55 : Con55 -> Ty55 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var55 (snoc55 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var55 g a -> Var55 (snoc55 g b) a)
 -> Var55 g a

vz55 : {g : _}-> {a : _} -> Var55 (snoc55 g a) a
vz55 = \ var, vz55, vs => vz55 _ _

vs55 : {g : _} -> {B : _} -> {a : _} -> Var55 g a -> Var55 (snoc55 g B) a
vs55 = \ x, var, vz55, vs55 => vs55 _ _ _ (x var vz55 vs55)

Tm55 : Con55 -> Ty55 -> Type
Tm55 = \ g, a =>
    (Tm55    : Con55 -> Ty55 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var55 g a -> Tm55 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm55 (snoc55 g a) B -> Tm55 g (arr55 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm55 g (arr55 a B) -> Tm55 g a -> Tm55 g B)
 -> Tm55 g a

var55 : {g : _} -> {a : _} -> Var55 g a -> Tm55 g a
var55 = \ x, tm, var55, lam, app => var55 _ _ x

lam55 : {g : _} -> {a : _} -> {B : _} -> Tm55 (snoc55 g a) B -> Tm55 g (arr55 a B)
lam55 = \ t, tm, var55, lam55, app => lam55 _ _ _ (t tm var55 lam55 app)

app55 : {g:_}->{a:_}->{B:_} -> Tm55 g (arr55 a B) -> Tm55 g a -> Tm55 g B
app55 = \ t, u, tm, var55, lam55, app55 => app55 _ _ _ (t tm var55 lam55 app55) (u tm var55 lam55 app55)

v055 : {g:_}->{a:_} -> Tm55 (snoc55 g a) a
v055 = var55 vz55

v155 : {g:_}->{a:_}-> {B:_}-> Tm55 (snoc55 (snoc55 g a) B) a
v155 = var55 (vs55 vz55)

v255 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm55 (snoc55 (snoc55 (snoc55 g a) B) C) a
v255 = var55 (vs55 (vs55 vz55))

v355 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm55 (snoc55 (snoc55 (snoc55 (snoc55 g a) B) C) D) a
v355 = var55 (vs55 (vs55 (vs55 vz55)))

v455 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm55 (snoc55 (snoc55 (snoc55 (snoc55 (snoc55 g a) B) C) D) E) a
v455 = var55 (vs55 (vs55 (vs55 (vs55 vz55))))

test55 : {g:_}-> {a:_} -> Tm55 g (arr55 (arr55 a a) (arr55 a a))
test55  = lam55 (lam55 (app55 v155 (app55 v155 (app55 v155 (app55 v155 (app55 v155 (app55 v155 v055)))))))
Ty56 : Type
Ty56 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty56 : Ty56
empty56 = \ _, empty, _ => empty

arr56 : Ty56 -> Ty56 -> Ty56
arr56 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con56 : Type
Con56 = (Con56 : Type)
 ->(nil  : Con56)
 ->(snoc : Con56 -> Ty56 -> Con56)
 -> Con56

nil56 : Con56
nil56 = \ con, nil56, snoc => nil56

snoc56 : Con56 -> Ty56 -> Con56
snoc56 = \ g, a, con, nil56, snoc56 => snoc56 (g con nil56 snoc56) a

Var56 : Con56 -> Ty56 -> Type
Var56 = \ g, a =>
    (Var56 : Con56 -> Ty56 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var56 (snoc56 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var56 g a -> Var56 (snoc56 g b) a)
 -> Var56 g a

vz56 : {g : _}-> {a : _} -> Var56 (snoc56 g a) a
vz56 = \ var, vz56, vs => vz56 _ _

vs56 : {g : _} -> {B : _} -> {a : _} -> Var56 g a -> Var56 (snoc56 g B) a
vs56 = \ x, var, vz56, vs56 => vs56 _ _ _ (x var vz56 vs56)

Tm56 : Con56 -> Ty56 -> Type
Tm56 = \ g, a =>
    (Tm56    : Con56 -> Ty56 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var56 g a -> Tm56 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm56 (snoc56 g a) B -> Tm56 g (arr56 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm56 g (arr56 a B) -> Tm56 g a -> Tm56 g B)
 -> Tm56 g a

var56 : {g : _} -> {a : _} -> Var56 g a -> Tm56 g a
var56 = \ x, tm, var56, lam, app => var56 _ _ x

lam56 : {g : _} -> {a : _} -> {B : _} -> Tm56 (snoc56 g a) B -> Tm56 g (arr56 a B)
lam56 = \ t, tm, var56, lam56, app => lam56 _ _ _ (t tm var56 lam56 app)

app56 : {g:_}->{a:_}->{B:_} -> Tm56 g (arr56 a B) -> Tm56 g a -> Tm56 g B
app56 = \ t, u, tm, var56, lam56, app56 => app56 _ _ _ (t tm var56 lam56 app56) (u tm var56 lam56 app56)

v056 : {g:_}->{a:_} -> Tm56 (snoc56 g a) a
v056 = var56 vz56

v156 : {g:_}->{a:_}-> {B:_}-> Tm56 (snoc56 (snoc56 g a) B) a
v156 = var56 (vs56 vz56)

v256 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm56 (snoc56 (snoc56 (snoc56 g a) B) C) a
v256 = var56 (vs56 (vs56 vz56))

v356 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm56 (snoc56 (snoc56 (snoc56 (snoc56 g a) B) C) D) a
v356 = var56 (vs56 (vs56 (vs56 vz56)))

v456 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm56 (snoc56 (snoc56 (snoc56 (snoc56 (snoc56 g a) B) C) D) E) a
v456 = var56 (vs56 (vs56 (vs56 (vs56 vz56))))

test56 : {g:_}-> {a:_} -> Tm56 g (arr56 (arr56 a a) (arr56 a a))
test56  = lam56 (lam56 (app56 v156 (app56 v156 (app56 v156 (app56 v156 (app56 v156 (app56 v156 v056)))))))
Ty57 : Type
Ty57 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty57 : Ty57
empty57 = \ _, empty, _ => empty

arr57 : Ty57 -> Ty57 -> Ty57
arr57 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con57 : Type
Con57 = (Con57 : Type)
 ->(nil  : Con57)
 ->(snoc : Con57 -> Ty57 -> Con57)
 -> Con57

nil57 : Con57
nil57 = \ con, nil57, snoc => nil57

snoc57 : Con57 -> Ty57 -> Con57
snoc57 = \ g, a, con, nil57, snoc57 => snoc57 (g con nil57 snoc57) a

Var57 : Con57 -> Ty57 -> Type
Var57 = \ g, a =>
    (Var57 : Con57 -> Ty57 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var57 (snoc57 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var57 g a -> Var57 (snoc57 g b) a)
 -> Var57 g a

vz57 : {g : _}-> {a : _} -> Var57 (snoc57 g a) a
vz57 = \ var, vz57, vs => vz57 _ _

vs57 : {g : _} -> {B : _} -> {a : _} -> Var57 g a -> Var57 (snoc57 g B) a
vs57 = \ x, var, vz57, vs57 => vs57 _ _ _ (x var vz57 vs57)

Tm57 : Con57 -> Ty57 -> Type
Tm57 = \ g, a =>
    (Tm57    : Con57 -> Ty57 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var57 g a -> Tm57 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm57 (snoc57 g a) B -> Tm57 g (arr57 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm57 g (arr57 a B) -> Tm57 g a -> Tm57 g B)
 -> Tm57 g a

var57 : {g : _} -> {a : _} -> Var57 g a -> Tm57 g a
var57 = \ x, tm, var57, lam, app => var57 _ _ x

lam57 : {g : _} -> {a : _} -> {B : _} -> Tm57 (snoc57 g a) B -> Tm57 g (arr57 a B)
lam57 = \ t, tm, var57, lam57, app => lam57 _ _ _ (t tm var57 lam57 app)

app57 : {g:_}->{a:_}->{B:_} -> Tm57 g (arr57 a B) -> Tm57 g a -> Tm57 g B
app57 = \ t, u, tm, var57, lam57, app57 => app57 _ _ _ (t tm var57 lam57 app57) (u tm var57 lam57 app57)

v057 : {g:_}->{a:_} -> Tm57 (snoc57 g a) a
v057 = var57 vz57

v157 : {g:_}->{a:_}-> {B:_}-> Tm57 (snoc57 (snoc57 g a) B) a
v157 = var57 (vs57 vz57)

v257 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm57 (snoc57 (snoc57 (snoc57 g a) B) C) a
v257 = var57 (vs57 (vs57 vz57))

v357 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm57 (snoc57 (snoc57 (snoc57 (snoc57 g a) B) C) D) a
v357 = var57 (vs57 (vs57 (vs57 vz57)))

v457 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm57 (snoc57 (snoc57 (snoc57 (snoc57 (snoc57 g a) B) C) D) E) a
v457 = var57 (vs57 (vs57 (vs57 (vs57 vz57))))

test57 : {g:_}-> {a:_} -> Tm57 g (arr57 (arr57 a a) (arr57 a a))
test57  = lam57 (lam57 (app57 v157 (app57 v157 (app57 v157 (app57 v157 (app57 v157 (app57 v157 v057)))))))
Ty58 : Type
Ty58 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty58 : Ty58
empty58 = \ _, empty, _ => empty

arr58 : Ty58 -> Ty58 -> Ty58
arr58 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con58 : Type
Con58 = (Con58 : Type)
 ->(nil  : Con58)
 ->(snoc : Con58 -> Ty58 -> Con58)
 -> Con58

nil58 : Con58
nil58 = \ con, nil58, snoc => nil58

snoc58 : Con58 -> Ty58 -> Con58
snoc58 = \ g, a, con, nil58, snoc58 => snoc58 (g con nil58 snoc58) a

Var58 : Con58 -> Ty58 -> Type
Var58 = \ g, a =>
    (Var58 : Con58 -> Ty58 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var58 (snoc58 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var58 g a -> Var58 (snoc58 g b) a)
 -> Var58 g a

vz58 : {g : _}-> {a : _} -> Var58 (snoc58 g a) a
vz58 = \ var, vz58, vs => vz58 _ _

vs58 : {g : _} -> {B : _} -> {a : _} -> Var58 g a -> Var58 (snoc58 g B) a
vs58 = \ x, var, vz58, vs58 => vs58 _ _ _ (x var vz58 vs58)

Tm58 : Con58 -> Ty58 -> Type
Tm58 = \ g, a =>
    (Tm58    : Con58 -> Ty58 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var58 g a -> Tm58 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm58 (snoc58 g a) B -> Tm58 g (arr58 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm58 g (arr58 a B) -> Tm58 g a -> Tm58 g B)
 -> Tm58 g a

var58 : {g : _} -> {a : _} -> Var58 g a -> Tm58 g a
var58 = \ x, tm, var58, lam, app => var58 _ _ x

lam58 : {g : _} -> {a : _} -> {B : _} -> Tm58 (snoc58 g a) B -> Tm58 g (arr58 a B)
lam58 = \ t, tm, var58, lam58, app => lam58 _ _ _ (t tm var58 lam58 app)

app58 : {g:_}->{a:_}->{B:_} -> Tm58 g (arr58 a B) -> Tm58 g a -> Tm58 g B
app58 = \ t, u, tm, var58, lam58, app58 => app58 _ _ _ (t tm var58 lam58 app58) (u tm var58 lam58 app58)

v058 : {g:_}->{a:_} -> Tm58 (snoc58 g a) a
v058 = var58 vz58

v158 : {g:_}->{a:_}-> {B:_}-> Tm58 (snoc58 (snoc58 g a) B) a
v158 = var58 (vs58 vz58)

v258 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm58 (snoc58 (snoc58 (snoc58 g a) B) C) a
v258 = var58 (vs58 (vs58 vz58))

v358 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm58 (snoc58 (snoc58 (snoc58 (snoc58 g a) B) C) D) a
v358 = var58 (vs58 (vs58 (vs58 vz58)))

v458 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm58 (snoc58 (snoc58 (snoc58 (snoc58 (snoc58 g a) B) C) D) E) a
v458 = var58 (vs58 (vs58 (vs58 (vs58 vz58))))

test58 : {g:_}-> {a:_} -> Tm58 g (arr58 (arr58 a a) (arr58 a a))
test58  = lam58 (lam58 (app58 v158 (app58 v158 (app58 v158 (app58 v158 (app58 v158 (app58 v158 v058)))))))
Ty59 : Type
Ty59 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty59 : Ty59
empty59 = \ _, empty, _ => empty

arr59 : Ty59 -> Ty59 -> Ty59
arr59 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con59 : Type
Con59 = (Con59 : Type)
 ->(nil  : Con59)
 ->(snoc : Con59 -> Ty59 -> Con59)
 -> Con59

nil59 : Con59
nil59 = \ con, nil59, snoc => nil59

snoc59 : Con59 -> Ty59 -> Con59
snoc59 = \ g, a, con, nil59, snoc59 => snoc59 (g con nil59 snoc59) a

Var59 : Con59 -> Ty59 -> Type
Var59 = \ g, a =>
    (Var59 : Con59 -> Ty59 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var59 (snoc59 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var59 g a -> Var59 (snoc59 g b) a)
 -> Var59 g a

vz59 : {g : _}-> {a : _} -> Var59 (snoc59 g a) a
vz59 = \ var, vz59, vs => vz59 _ _

vs59 : {g : _} -> {B : _} -> {a : _} -> Var59 g a -> Var59 (snoc59 g B) a
vs59 = \ x, var, vz59, vs59 => vs59 _ _ _ (x var vz59 vs59)

Tm59 : Con59 -> Ty59 -> Type
Tm59 = \ g, a =>
    (Tm59    : Con59 -> Ty59 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var59 g a -> Tm59 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm59 (snoc59 g a) B -> Tm59 g (arr59 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm59 g (arr59 a B) -> Tm59 g a -> Tm59 g B)
 -> Tm59 g a

var59 : {g : _} -> {a : _} -> Var59 g a -> Tm59 g a
var59 = \ x, tm, var59, lam, app => var59 _ _ x

lam59 : {g : _} -> {a : _} -> {B : _} -> Tm59 (snoc59 g a) B -> Tm59 g (arr59 a B)
lam59 = \ t, tm, var59, lam59, app => lam59 _ _ _ (t tm var59 lam59 app)

app59 : {g:_}->{a:_}->{B:_} -> Tm59 g (arr59 a B) -> Tm59 g a -> Tm59 g B
app59 = \ t, u, tm, var59, lam59, app59 => app59 _ _ _ (t tm var59 lam59 app59) (u tm var59 lam59 app59)

v059 : {g:_}->{a:_} -> Tm59 (snoc59 g a) a
v059 = var59 vz59

v159 : {g:_}->{a:_}-> {B:_}-> Tm59 (snoc59 (snoc59 g a) B) a
v159 = var59 (vs59 vz59)

v259 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm59 (snoc59 (snoc59 (snoc59 g a) B) C) a
v259 = var59 (vs59 (vs59 vz59))

v359 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm59 (snoc59 (snoc59 (snoc59 (snoc59 g a) B) C) D) a
v359 = var59 (vs59 (vs59 (vs59 vz59)))

v459 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm59 (snoc59 (snoc59 (snoc59 (snoc59 (snoc59 g a) B) C) D) E) a
v459 = var59 (vs59 (vs59 (vs59 (vs59 vz59))))

test59 : {g:_}-> {a:_} -> Tm59 g (arr59 (arr59 a a) (arr59 a a))
test59  = lam59 (lam59 (app59 v159 (app59 v159 (app59 v159 (app59 v159 (app59 v159 (app59 v159 v059)))))))
Ty60 : Type
Ty60 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty60 : Ty60
empty60 = \ _, empty, _ => empty

arr60 : Ty60 -> Ty60 -> Ty60
arr60 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con60 : Type
Con60 = (Con60 : Type)
 ->(nil  : Con60)
 ->(snoc : Con60 -> Ty60 -> Con60)
 -> Con60

nil60 : Con60
nil60 = \ con, nil60, snoc => nil60

snoc60 : Con60 -> Ty60 -> Con60
snoc60 = \ g, a, con, nil60, snoc60 => snoc60 (g con nil60 snoc60) a

Var60 : Con60 -> Ty60 -> Type
Var60 = \ g, a =>
    (Var60 : Con60 -> Ty60 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var60 (snoc60 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var60 g a -> Var60 (snoc60 g b) a)
 -> Var60 g a

vz60 : {g : _}-> {a : _} -> Var60 (snoc60 g a) a
vz60 = \ var, vz60, vs => vz60 _ _

vs60 : {g : _} -> {B : _} -> {a : _} -> Var60 g a -> Var60 (snoc60 g B) a
vs60 = \ x, var, vz60, vs60 => vs60 _ _ _ (x var vz60 vs60)

Tm60 : Con60 -> Ty60 -> Type
Tm60 = \ g, a =>
    (Tm60    : Con60 -> Ty60 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var60 g a -> Tm60 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm60 (snoc60 g a) B -> Tm60 g (arr60 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm60 g (arr60 a B) -> Tm60 g a -> Tm60 g B)
 -> Tm60 g a

var60 : {g : _} -> {a : _} -> Var60 g a -> Tm60 g a
var60 = \ x, tm, var60, lam, app => var60 _ _ x

lam60 : {g : _} -> {a : _} -> {B : _} -> Tm60 (snoc60 g a) B -> Tm60 g (arr60 a B)
lam60 = \ t, tm, var60, lam60, app => lam60 _ _ _ (t tm var60 lam60 app)

app60 : {g:_}->{a:_}->{B:_} -> Tm60 g (arr60 a B) -> Tm60 g a -> Tm60 g B
app60 = \ t, u, tm, var60, lam60, app60 => app60 _ _ _ (t tm var60 lam60 app60) (u tm var60 lam60 app60)

v060 : {g:_}->{a:_} -> Tm60 (snoc60 g a) a
v060 = var60 vz60

v160 : {g:_}->{a:_}-> {B:_}-> Tm60 (snoc60 (snoc60 g a) B) a
v160 = var60 (vs60 vz60)

v260 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm60 (snoc60 (snoc60 (snoc60 g a) B) C) a
v260 = var60 (vs60 (vs60 vz60))

v360 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm60 (snoc60 (snoc60 (snoc60 (snoc60 g a) B) C) D) a
v360 = var60 (vs60 (vs60 (vs60 vz60)))

v460 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm60 (snoc60 (snoc60 (snoc60 (snoc60 (snoc60 g a) B) C) D) E) a
v460 = var60 (vs60 (vs60 (vs60 (vs60 vz60))))

test60 : {g:_}-> {a:_} -> Tm60 g (arr60 (arr60 a a) (arr60 a a))
test60  = lam60 (lam60 (app60 v160 (app60 v160 (app60 v160 (app60 v160 (app60 v160 (app60 v160 v060)))))))
Ty61 : Type
Ty61 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty61 : Ty61
empty61 = \ _, empty, _ => empty

arr61 : Ty61 -> Ty61 -> Ty61
arr61 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con61 : Type
Con61 = (Con61 : Type)
 ->(nil  : Con61)
 ->(snoc : Con61 -> Ty61 -> Con61)
 -> Con61

nil61 : Con61
nil61 = \ con, nil61, snoc => nil61

snoc61 : Con61 -> Ty61 -> Con61
snoc61 = \ g, a, con, nil61, snoc61 => snoc61 (g con nil61 snoc61) a

Var61 : Con61 -> Ty61 -> Type
Var61 = \ g, a =>
    (Var61 : Con61 -> Ty61 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var61 (snoc61 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var61 g a -> Var61 (snoc61 g b) a)
 -> Var61 g a

vz61 : {g : _}-> {a : _} -> Var61 (snoc61 g a) a
vz61 = \ var, vz61, vs => vz61 _ _

vs61 : {g : _} -> {B : _} -> {a : _} -> Var61 g a -> Var61 (snoc61 g B) a
vs61 = \ x, var, vz61, vs61 => vs61 _ _ _ (x var vz61 vs61)

Tm61 : Con61 -> Ty61 -> Type
Tm61 = \ g, a =>
    (Tm61    : Con61 -> Ty61 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var61 g a -> Tm61 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm61 (snoc61 g a) B -> Tm61 g (arr61 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm61 g (arr61 a B) -> Tm61 g a -> Tm61 g B)
 -> Tm61 g a

var61 : {g : _} -> {a : _} -> Var61 g a -> Tm61 g a
var61 = \ x, tm, var61, lam, app => var61 _ _ x

lam61 : {g : _} -> {a : _} -> {B : _} -> Tm61 (snoc61 g a) B -> Tm61 g (arr61 a B)
lam61 = \ t, tm, var61, lam61, app => lam61 _ _ _ (t tm var61 lam61 app)

app61 : {g:_}->{a:_}->{B:_} -> Tm61 g (arr61 a B) -> Tm61 g a -> Tm61 g B
app61 = \ t, u, tm, var61, lam61, app61 => app61 _ _ _ (t tm var61 lam61 app61) (u tm var61 lam61 app61)

v061 : {g:_}->{a:_} -> Tm61 (snoc61 g a) a
v061 = var61 vz61

v161 : {g:_}->{a:_}-> {B:_}-> Tm61 (snoc61 (snoc61 g a) B) a
v161 = var61 (vs61 vz61)

v261 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm61 (snoc61 (snoc61 (snoc61 g a) B) C) a
v261 = var61 (vs61 (vs61 vz61))

v361 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm61 (snoc61 (snoc61 (snoc61 (snoc61 g a) B) C) D) a
v361 = var61 (vs61 (vs61 (vs61 vz61)))

v461 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm61 (snoc61 (snoc61 (snoc61 (snoc61 (snoc61 g a) B) C) D) E) a
v461 = var61 (vs61 (vs61 (vs61 (vs61 vz61))))

test61 : {g:_}-> {a:_} -> Tm61 g (arr61 (arr61 a a) (arr61 a a))
test61  = lam61 (lam61 (app61 v161 (app61 v161 (app61 v161 (app61 v161 (app61 v161 (app61 v161 v061)))))))
Ty62 : Type
Ty62 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty62 : Ty62
empty62 = \ _, empty, _ => empty

arr62 : Ty62 -> Ty62 -> Ty62
arr62 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con62 : Type
Con62 = (Con62 : Type)
 ->(nil  : Con62)
 ->(snoc : Con62 -> Ty62 -> Con62)
 -> Con62

nil62 : Con62
nil62 = \ con, nil62, snoc => nil62

snoc62 : Con62 -> Ty62 -> Con62
snoc62 = \ g, a, con, nil62, snoc62 => snoc62 (g con nil62 snoc62) a

Var62 : Con62 -> Ty62 -> Type
Var62 = \ g, a =>
    (Var62 : Con62 -> Ty62 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var62 (snoc62 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var62 g a -> Var62 (snoc62 g b) a)
 -> Var62 g a

vz62 : {g : _}-> {a : _} -> Var62 (snoc62 g a) a
vz62 = \ var, vz62, vs => vz62 _ _

vs62 : {g : _} -> {B : _} -> {a : _} -> Var62 g a -> Var62 (snoc62 g B) a
vs62 = \ x, var, vz62, vs62 => vs62 _ _ _ (x var vz62 vs62)

Tm62 : Con62 -> Ty62 -> Type
Tm62 = \ g, a =>
    (Tm62    : Con62 -> Ty62 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var62 g a -> Tm62 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm62 (snoc62 g a) B -> Tm62 g (arr62 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm62 g (arr62 a B) -> Tm62 g a -> Tm62 g B)
 -> Tm62 g a

var62 : {g : _} -> {a : _} -> Var62 g a -> Tm62 g a
var62 = \ x, tm, var62, lam, app => var62 _ _ x

lam62 : {g : _} -> {a : _} -> {B : _} -> Tm62 (snoc62 g a) B -> Tm62 g (arr62 a B)
lam62 = \ t, tm, var62, lam62, app => lam62 _ _ _ (t tm var62 lam62 app)

app62 : {g:_}->{a:_}->{B:_} -> Tm62 g (arr62 a B) -> Tm62 g a -> Tm62 g B
app62 = \ t, u, tm, var62, lam62, app62 => app62 _ _ _ (t tm var62 lam62 app62) (u tm var62 lam62 app62)

v062 : {g:_}->{a:_} -> Tm62 (snoc62 g a) a
v062 = var62 vz62

v162 : {g:_}->{a:_}-> {B:_}-> Tm62 (snoc62 (snoc62 g a) B) a
v162 = var62 (vs62 vz62)

v262 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm62 (snoc62 (snoc62 (snoc62 g a) B) C) a
v262 = var62 (vs62 (vs62 vz62))

v362 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm62 (snoc62 (snoc62 (snoc62 (snoc62 g a) B) C) D) a
v362 = var62 (vs62 (vs62 (vs62 vz62)))

v462 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm62 (snoc62 (snoc62 (snoc62 (snoc62 (snoc62 g a) B) C) D) E) a
v462 = var62 (vs62 (vs62 (vs62 (vs62 vz62))))

test62 : {g:_}-> {a:_} -> Tm62 g (arr62 (arr62 a a) (arr62 a a))
test62  = lam62 (lam62 (app62 v162 (app62 v162 (app62 v162 (app62 v162 (app62 v162 (app62 v162 v062)))))))
Ty63 : Type
Ty63 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty63 : Ty63
empty63 = \ _, empty, _ => empty

arr63 : Ty63 -> Ty63 -> Ty63
arr63 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con63 : Type
Con63 = (Con63 : Type)
 ->(nil  : Con63)
 ->(snoc : Con63 -> Ty63 -> Con63)
 -> Con63

nil63 : Con63
nil63 = \ con, nil63, snoc => nil63

snoc63 : Con63 -> Ty63 -> Con63
snoc63 = \ g, a, con, nil63, snoc63 => snoc63 (g con nil63 snoc63) a

Var63 : Con63 -> Ty63 -> Type
Var63 = \ g, a =>
    (Var63 : Con63 -> Ty63 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var63 (snoc63 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var63 g a -> Var63 (snoc63 g b) a)
 -> Var63 g a

vz63 : {g : _}-> {a : _} -> Var63 (snoc63 g a) a
vz63 = \ var, vz63, vs => vz63 _ _

vs63 : {g : _} -> {B : _} -> {a : _} -> Var63 g a -> Var63 (snoc63 g B) a
vs63 = \ x, var, vz63, vs63 => vs63 _ _ _ (x var vz63 vs63)

Tm63 : Con63 -> Ty63 -> Type
Tm63 = \ g, a =>
    (Tm63    : Con63 -> Ty63 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var63 g a -> Tm63 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm63 (snoc63 g a) B -> Tm63 g (arr63 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm63 g (arr63 a B) -> Tm63 g a -> Tm63 g B)
 -> Tm63 g a

var63 : {g : _} -> {a : _} -> Var63 g a -> Tm63 g a
var63 = \ x, tm, var63, lam, app => var63 _ _ x

lam63 : {g : _} -> {a : _} -> {B : _} -> Tm63 (snoc63 g a) B -> Tm63 g (arr63 a B)
lam63 = \ t, tm, var63, lam63, app => lam63 _ _ _ (t tm var63 lam63 app)

app63 : {g:_}->{a:_}->{B:_} -> Tm63 g (arr63 a B) -> Tm63 g a -> Tm63 g B
app63 = \ t, u, tm, var63, lam63, app63 => app63 _ _ _ (t tm var63 lam63 app63) (u tm var63 lam63 app63)

v063 : {g:_}->{a:_} -> Tm63 (snoc63 g a) a
v063 = var63 vz63

v163 : {g:_}->{a:_}-> {B:_}-> Tm63 (snoc63 (snoc63 g a) B) a
v163 = var63 (vs63 vz63)

v263 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm63 (snoc63 (snoc63 (snoc63 g a) B) C) a
v263 = var63 (vs63 (vs63 vz63))

v363 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm63 (snoc63 (snoc63 (snoc63 (snoc63 g a) B) C) D) a
v363 = var63 (vs63 (vs63 (vs63 vz63)))

v463 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm63 (snoc63 (snoc63 (snoc63 (snoc63 (snoc63 g a) B) C) D) E) a
v463 = var63 (vs63 (vs63 (vs63 (vs63 vz63))))

test63 : {g:_}-> {a:_} -> Tm63 g (arr63 (arr63 a a) (arr63 a a))
test63  = lam63 (lam63 (app63 v163 (app63 v163 (app63 v163 (app63 v163 (app63 v163 (app63 v163 v063)))))))
Ty64 : Type
Ty64 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty64 : Ty64
empty64 = \ _, empty, _ => empty

arr64 : Ty64 -> Ty64 -> Ty64
arr64 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con64 : Type
Con64 = (Con64 : Type)
 ->(nil  : Con64)
 ->(snoc : Con64 -> Ty64 -> Con64)
 -> Con64

nil64 : Con64
nil64 = \ con, nil64, snoc => nil64

snoc64 : Con64 -> Ty64 -> Con64
snoc64 = \ g, a, con, nil64, snoc64 => snoc64 (g con nil64 snoc64) a

Var64 : Con64 -> Ty64 -> Type
Var64 = \ g, a =>
    (Var64 : Con64 -> Ty64 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var64 (snoc64 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var64 g a -> Var64 (snoc64 g b) a)
 -> Var64 g a

vz64 : {g : _}-> {a : _} -> Var64 (snoc64 g a) a
vz64 = \ var, vz64, vs => vz64 _ _

vs64 : {g : _} -> {B : _} -> {a : _} -> Var64 g a -> Var64 (snoc64 g B) a
vs64 = \ x, var, vz64, vs64 => vs64 _ _ _ (x var vz64 vs64)

Tm64 : Con64 -> Ty64 -> Type
Tm64 = \ g, a =>
    (Tm64    : Con64 -> Ty64 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var64 g a -> Tm64 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm64 (snoc64 g a) B -> Tm64 g (arr64 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm64 g (arr64 a B) -> Tm64 g a -> Tm64 g B)
 -> Tm64 g a

var64 : {g : _} -> {a : _} -> Var64 g a -> Tm64 g a
var64 = \ x, tm, var64, lam, app => var64 _ _ x

lam64 : {g : _} -> {a : _} -> {B : _} -> Tm64 (snoc64 g a) B -> Tm64 g (arr64 a B)
lam64 = \ t, tm, var64, lam64, app => lam64 _ _ _ (t tm var64 lam64 app)

app64 : {g:_}->{a:_}->{B:_} -> Tm64 g (arr64 a B) -> Tm64 g a -> Tm64 g B
app64 = \ t, u, tm, var64, lam64, app64 => app64 _ _ _ (t tm var64 lam64 app64) (u tm var64 lam64 app64)

v064 : {g:_}->{a:_} -> Tm64 (snoc64 g a) a
v064 = var64 vz64

v164 : {g:_}->{a:_}-> {B:_}-> Tm64 (snoc64 (snoc64 g a) B) a
v164 = var64 (vs64 vz64)

v264 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm64 (snoc64 (snoc64 (snoc64 g a) B) C) a
v264 = var64 (vs64 (vs64 vz64))

v364 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm64 (snoc64 (snoc64 (snoc64 (snoc64 g a) B) C) D) a
v364 = var64 (vs64 (vs64 (vs64 vz64)))

v464 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm64 (snoc64 (snoc64 (snoc64 (snoc64 (snoc64 g a) B) C) D) E) a
v464 = var64 (vs64 (vs64 (vs64 (vs64 vz64))))

test64 : {g:_}-> {a:_} -> Tm64 g (arr64 (arr64 a a) (arr64 a a))
test64  = lam64 (lam64 (app64 v164 (app64 v164 (app64 v164 (app64 v164 (app64 v164 (app64 v164 v064)))))))
Ty65 : Type
Ty65 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty65 : Ty65
empty65 = \ _, empty, _ => empty

arr65 : Ty65 -> Ty65 -> Ty65
arr65 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con65 : Type
Con65 = (Con65 : Type)
 ->(nil  : Con65)
 ->(snoc : Con65 -> Ty65 -> Con65)
 -> Con65

nil65 : Con65
nil65 = \ con, nil65, snoc => nil65

snoc65 : Con65 -> Ty65 -> Con65
snoc65 = \ g, a, con, nil65, snoc65 => snoc65 (g con nil65 snoc65) a

Var65 : Con65 -> Ty65 -> Type
Var65 = \ g, a =>
    (Var65 : Con65 -> Ty65 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var65 (snoc65 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var65 g a -> Var65 (snoc65 g b) a)
 -> Var65 g a

vz65 : {g : _}-> {a : _} -> Var65 (snoc65 g a) a
vz65 = \ var, vz65, vs => vz65 _ _

vs65 : {g : _} -> {B : _} -> {a : _} -> Var65 g a -> Var65 (snoc65 g B) a
vs65 = \ x, var, vz65, vs65 => vs65 _ _ _ (x var vz65 vs65)

Tm65 : Con65 -> Ty65 -> Type
Tm65 = \ g, a =>
    (Tm65    : Con65 -> Ty65 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var65 g a -> Tm65 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm65 (snoc65 g a) B -> Tm65 g (arr65 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm65 g (arr65 a B) -> Tm65 g a -> Tm65 g B)
 -> Tm65 g a

var65 : {g : _} -> {a : _} -> Var65 g a -> Tm65 g a
var65 = \ x, tm, var65, lam, app => var65 _ _ x

lam65 : {g : _} -> {a : _} -> {B : _} -> Tm65 (snoc65 g a) B -> Tm65 g (arr65 a B)
lam65 = \ t, tm, var65, lam65, app => lam65 _ _ _ (t tm var65 lam65 app)

app65 : {g:_}->{a:_}->{B:_} -> Tm65 g (arr65 a B) -> Tm65 g a -> Tm65 g B
app65 = \ t, u, tm, var65, lam65, app65 => app65 _ _ _ (t tm var65 lam65 app65) (u tm var65 lam65 app65)

v065 : {g:_}->{a:_} -> Tm65 (snoc65 g a) a
v065 = var65 vz65

v165 : {g:_}->{a:_}-> {B:_}-> Tm65 (snoc65 (snoc65 g a) B) a
v165 = var65 (vs65 vz65)

v265 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm65 (snoc65 (snoc65 (snoc65 g a) B) C) a
v265 = var65 (vs65 (vs65 vz65))

v365 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm65 (snoc65 (snoc65 (snoc65 (snoc65 g a) B) C) D) a
v365 = var65 (vs65 (vs65 (vs65 vz65)))

v465 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm65 (snoc65 (snoc65 (snoc65 (snoc65 (snoc65 g a) B) C) D) E) a
v465 = var65 (vs65 (vs65 (vs65 (vs65 vz65))))

test65 : {g:_}-> {a:_} -> Tm65 g (arr65 (arr65 a a) (arr65 a a))
test65  = lam65 (lam65 (app65 v165 (app65 v165 (app65 v165 (app65 v165 (app65 v165 (app65 v165 v065)))))))
Ty66 : Type
Ty66 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty66 : Ty66
empty66 = \ _, empty, _ => empty

arr66 : Ty66 -> Ty66 -> Ty66
arr66 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con66 : Type
Con66 = (Con66 : Type)
 ->(nil  : Con66)
 ->(snoc : Con66 -> Ty66 -> Con66)
 -> Con66

nil66 : Con66
nil66 = \ con, nil66, snoc => nil66

snoc66 : Con66 -> Ty66 -> Con66
snoc66 = \ g, a, con, nil66, snoc66 => snoc66 (g con nil66 snoc66) a

Var66 : Con66 -> Ty66 -> Type
Var66 = \ g, a =>
    (Var66 : Con66 -> Ty66 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var66 (snoc66 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var66 g a -> Var66 (snoc66 g b) a)
 -> Var66 g a

vz66 : {g : _}-> {a : _} -> Var66 (snoc66 g a) a
vz66 = \ var, vz66, vs => vz66 _ _

vs66 : {g : _} -> {B : _} -> {a : _} -> Var66 g a -> Var66 (snoc66 g B) a
vs66 = \ x, var, vz66, vs66 => vs66 _ _ _ (x var vz66 vs66)

Tm66 : Con66 -> Ty66 -> Type
Tm66 = \ g, a =>
    (Tm66    : Con66 -> Ty66 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var66 g a -> Tm66 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm66 (snoc66 g a) B -> Tm66 g (arr66 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm66 g (arr66 a B) -> Tm66 g a -> Tm66 g B)
 -> Tm66 g a

var66 : {g : _} -> {a : _} -> Var66 g a -> Tm66 g a
var66 = \ x, tm, var66, lam, app => var66 _ _ x

lam66 : {g : _} -> {a : _} -> {B : _} -> Tm66 (snoc66 g a) B -> Tm66 g (arr66 a B)
lam66 = \ t, tm, var66, lam66, app => lam66 _ _ _ (t tm var66 lam66 app)

app66 : {g:_}->{a:_}->{B:_} -> Tm66 g (arr66 a B) -> Tm66 g a -> Tm66 g B
app66 = \ t, u, tm, var66, lam66, app66 => app66 _ _ _ (t tm var66 lam66 app66) (u tm var66 lam66 app66)

v066 : {g:_}->{a:_} -> Tm66 (snoc66 g a) a
v066 = var66 vz66

v166 : {g:_}->{a:_}-> {B:_}-> Tm66 (snoc66 (snoc66 g a) B) a
v166 = var66 (vs66 vz66)

v266 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm66 (snoc66 (snoc66 (snoc66 g a) B) C) a
v266 = var66 (vs66 (vs66 vz66))

v366 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm66 (snoc66 (snoc66 (snoc66 (snoc66 g a) B) C) D) a
v366 = var66 (vs66 (vs66 (vs66 vz66)))

v466 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm66 (snoc66 (snoc66 (snoc66 (snoc66 (snoc66 g a) B) C) D) E) a
v466 = var66 (vs66 (vs66 (vs66 (vs66 vz66))))

test66 : {g:_}-> {a:_} -> Tm66 g (arr66 (arr66 a a) (arr66 a a))
test66  = lam66 (lam66 (app66 v166 (app66 v166 (app66 v166 (app66 v166 (app66 v166 (app66 v166 v066)))))))
Ty67 : Type
Ty67 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty67 : Ty67
empty67 = \ _, empty, _ => empty

arr67 : Ty67 -> Ty67 -> Ty67
arr67 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con67 : Type
Con67 = (Con67 : Type)
 ->(nil  : Con67)
 ->(snoc : Con67 -> Ty67 -> Con67)
 -> Con67

nil67 : Con67
nil67 = \ con, nil67, snoc => nil67

snoc67 : Con67 -> Ty67 -> Con67
snoc67 = \ g, a, con, nil67, snoc67 => snoc67 (g con nil67 snoc67) a

Var67 : Con67 -> Ty67 -> Type
Var67 = \ g, a =>
    (Var67 : Con67 -> Ty67 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var67 (snoc67 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var67 g a -> Var67 (snoc67 g b) a)
 -> Var67 g a

vz67 : {g : _}-> {a : _} -> Var67 (snoc67 g a) a
vz67 = \ var, vz67, vs => vz67 _ _

vs67 : {g : _} -> {B : _} -> {a : _} -> Var67 g a -> Var67 (snoc67 g B) a
vs67 = \ x, var, vz67, vs67 => vs67 _ _ _ (x var vz67 vs67)

Tm67 : Con67 -> Ty67 -> Type
Tm67 = \ g, a =>
    (Tm67    : Con67 -> Ty67 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var67 g a -> Tm67 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm67 (snoc67 g a) B -> Tm67 g (arr67 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm67 g (arr67 a B) -> Tm67 g a -> Tm67 g B)
 -> Tm67 g a

var67 : {g : _} -> {a : _} -> Var67 g a -> Tm67 g a
var67 = \ x, tm, var67, lam, app => var67 _ _ x

lam67 : {g : _} -> {a : _} -> {B : _} -> Tm67 (snoc67 g a) B -> Tm67 g (arr67 a B)
lam67 = \ t, tm, var67, lam67, app => lam67 _ _ _ (t tm var67 lam67 app)

app67 : {g:_}->{a:_}->{B:_} -> Tm67 g (arr67 a B) -> Tm67 g a -> Tm67 g B
app67 = \ t, u, tm, var67, lam67, app67 => app67 _ _ _ (t tm var67 lam67 app67) (u tm var67 lam67 app67)

v067 : {g:_}->{a:_} -> Tm67 (snoc67 g a) a
v067 = var67 vz67

v167 : {g:_}->{a:_}-> {B:_}-> Tm67 (snoc67 (snoc67 g a) B) a
v167 = var67 (vs67 vz67)

v267 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm67 (snoc67 (snoc67 (snoc67 g a) B) C) a
v267 = var67 (vs67 (vs67 vz67))

v367 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm67 (snoc67 (snoc67 (snoc67 (snoc67 g a) B) C) D) a
v367 = var67 (vs67 (vs67 (vs67 vz67)))

v467 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm67 (snoc67 (snoc67 (snoc67 (snoc67 (snoc67 g a) B) C) D) E) a
v467 = var67 (vs67 (vs67 (vs67 (vs67 vz67))))

test67 : {g:_}-> {a:_} -> Tm67 g (arr67 (arr67 a a) (arr67 a a))
test67  = lam67 (lam67 (app67 v167 (app67 v167 (app67 v167 (app67 v167 (app67 v167 (app67 v167 v067)))))))
Ty68 : Type
Ty68 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty68 : Ty68
empty68 = \ _, empty, _ => empty

arr68 : Ty68 -> Ty68 -> Ty68
arr68 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con68 : Type
Con68 = (Con68 : Type)
 ->(nil  : Con68)
 ->(snoc : Con68 -> Ty68 -> Con68)
 -> Con68

nil68 : Con68
nil68 = \ con, nil68, snoc => nil68

snoc68 : Con68 -> Ty68 -> Con68
snoc68 = \ g, a, con, nil68, snoc68 => snoc68 (g con nil68 snoc68) a

Var68 : Con68 -> Ty68 -> Type
Var68 = \ g, a =>
    (Var68 : Con68 -> Ty68 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var68 (snoc68 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var68 g a -> Var68 (snoc68 g b) a)
 -> Var68 g a

vz68 : {g : _}-> {a : _} -> Var68 (snoc68 g a) a
vz68 = \ var, vz68, vs => vz68 _ _

vs68 : {g : _} -> {B : _} -> {a : _} -> Var68 g a -> Var68 (snoc68 g B) a
vs68 = \ x, var, vz68, vs68 => vs68 _ _ _ (x var vz68 vs68)

Tm68 : Con68 -> Ty68 -> Type
Tm68 = \ g, a =>
    (Tm68    : Con68 -> Ty68 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var68 g a -> Tm68 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm68 (snoc68 g a) B -> Tm68 g (arr68 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm68 g (arr68 a B) -> Tm68 g a -> Tm68 g B)
 -> Tm68 g a

var68 : {g : _} -> {a : _} -> Var68 g a -> Tm68 g a
var68 = \ x, tm, var68, lam, app => var68 _ _ x

lam68 : {g : _} -> {a : _} -> {B : _} -> Tm68 (snoc68 g a) B -> Tm68 g (arr68 a B)
lam68 = \ t, tm, var68, lam68, app => lam68 _ _ _ (t tm var68 lam68 app)

app68 : {g:_}->{a:_}->{B:_} -> Tm68 g (arr68 a B) -> Tm68 g a -> Tm68 g B
app68 = \ t, u, tm, var68, lam68, app68 => app68 _ _ _ (t tm var68 lam68 app68) (u tm var68 lam68 app68)

v068 : {g:_}->{a:_} -> Tm68 (snoc68 g a) a
v068 = var68 vz68

v168 : {g:_}->{a:_}-> {B:_}-> Tm68 (snoc68 (snoc68 g a) B) a
v168 = var68 (vs68 vz68)

v268 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm68 (snoc68 (snoc68 (snoc68 g a) B) C) a
v268 = var68 (vs68 (vs68 vz68))

v368 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm68 (snoc68 (snoc68 (snoc68 (snoc68 g a) B) C) D) a
v368 = var68 (vs68 (vs68 (vs68 vz68)))

v468 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm68 (snoc68 (snoc68 (snoc68 (snoc68 (snoc68 g a) B) C) D) E) a
v468 = var68 (vs68 (vs68 (vs68 (vs68 vz68))))

test68 : {g:_}-> {a:_} -> Tm68 g (arr68 (arr68 a a) (arr68 a a))
test68  = lam68 (lam68 (app68 v168 (app68 v168 (app68 v168 (app68 v168 (app68 v168 (app68 v168 v068)))))))
Ty69 : Type
Ty69 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty69 : Ty69
empty69 = \ _, empty, _ => empty

arr69 : Ty69 -> Ty69 -> Ty69
arr69 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con69 : Type
Con69 = (Con69 : Type)
 ->(nil  : Con69)
 ->(snoc : Con69 -> Ty69 -> Con69)
 -> Con69

nil69 : Con69
nil69 = \ con, nil69, snoc => nil69

snoc69 : Con69 -> Ty69 -> Con69
snoc69 = \ g, a, con, nil69, snoc69 => snoc69 (g con nil69 snoc69) a

Var69 : Con69 -> Ty69 -> Type
Var69 = \ g, a =>
    (Var69 : Con69 -> Ty69 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var69 (snoc69 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var69 g a -> Var69 (snoc69 g b) a)
 -> Var69 g a

vz69 : {g : _}-> {a : _} -> Var69 (snoc69 g a) a
vz69 = \ var, vz69, vs => vz69 _ _

vs69 : {g : _} -> {B : _} -> {a : _} -> Var69 g a -> Var69 (snoc69 g B) a
vs69 = \ x, var, vz69, vs69 => vs69 _ _ _ (x var vz69 vs69)

Tm69 : Con69 -> Ty69 -> Type
Tm69 = \ g, a =>
    (Tm69    : Con69 -> Ty69 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var69 g a -> Tm69 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm69 (snoc69 g a) B -> Tm69 g (arr69 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm69 g (arr69 a B) -> Tm69 g a -> Tm69 g B)
 -> Tm69 g a

var69 : {g : _} -> {a : _} -> Var69 g a -> Tm69 g a
var69 = \ x, tm, var69, lam, app => var69 _ _ x

lam69 : {g : _} -> {a : _} -> {B : _} -> Tm69 (snoc69 g a) B -> Tm69 g (arr69 a B)
lam69 = \ t, tm, var69, lam69, app => lam69 _ _ _ (t tm var69 lam69 app)

app69 : {g:_}->{a:_}->{B:_} -> Tm69 g (arr69 a B) -> Tm69 g a -> Tm69 g B
app69 = \ t, u, tm, var69, lam69, app69 => app69 _ _ _ (t tm var69 lam69 app69) (u tm var69 lam69 app69)

v069 : {g:_}->{a:_} -> Tm69 (snoc69 g a) a
v069 = var69 vz69

v169 : {g:_}->{a:_}-> {B:_}-> Tm69 (snoc69 (snoc69 g a) B) a
v169 = var69 (vs69 vz69)

v269 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm69 (snoc69 (snoc69 (snoc69 g a) B) C) a
v269 = var69 (vs69 (vs69 vz69))

v369 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm69 (snoc69 (snoc69 (snoc69 (snoc69 g a) B) C) D) a
v369 = var69 (vs69 (vs69 (vs69 vz69)))

v469 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm69 (snoc69 (snoc69 (snoc69 (snoc69 (snoc69 g a) B) C) D) E) a
v469 = var69 (vs69 (vs69 (vs69 (vs69 vz69))))

test69 : {g:_}-> {a:_} -> Tm69 g (arr69 (arr69 a a) (arr69 a a))
test69  = lam69 (lam69 (app69 v169 (app69 v169 (app69 v169 (app69 v169 (app69 v169 (app69 v169 v069)))))))
Ty70 : Type
Ty70 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty70 : Ty70
empty70 = \ _, empty, _ => empty

arr70 : Ty70 -> Ty70 -> Ty70
arr70 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con70 : Type
Con70 = (Con70 : Type)
 ->(nil  : Con70)
 ->(snoc : Con70 -> Ty70 -> Con70)
 -> Con70

nil70 : Con70
nil70 = \ con, nil70, snoc => nil70

snoc70 : Con70 -> Ty70 -> Con70
snoc70 = \ g, a, con, nil70, snoc70 => snoc70 (g con nil70 snoc70) a

Var70 : Con70 -> Ty70 -> Type
Var70 = \ g, a =>
    (Var70 : Con70 -> Ty70 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var70 (snoc70 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var70 g a -> Var70 (snoc70 g b) a)
 -> Var70 g a

vz70 : {g : _}-> {a : _} -> Var70 (snoc70 g a) a
vz70 = \ var, vz70, vs => vz70 _ _

vs70 : {g : _} -> {B : _} -> {a : _} -> Var70 g a -> Var70 (snoc70 g B) a
vs70 = \ x, var, vz70, vs70 => vs70 _ _ _ (x var vz70 vs70)

Tm70 : Con70 -> Ty70 -> Type
Tm70 = \ g, a =>
    (Tm70    : Con70 -> Ty70 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var70 g a -> Tm70 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm70 (snoc70 g a) B -> Tm70 g (arr70 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm70 g (arr70 a B) -> Tm70 g a -> Tm70 g B)
 -> Tm70 g a

var70 : {g : _} -> {a : _} -> Var70 g a -> Tm70 g a
var70 = \ x, tm, var70, lam, app => var70 _ _ x

lam70 : {g : _} -> {a : _} -> {B : _} -> Tm70 (snoc70 g a) B -> Tm70 g (arr70 a B)
lam70 = \ t, tm, var70, lam70, app => lam70 _ _ _ (t tm var70 lam70 app)

app70 : {g:_}->{a:_}->{B:_} -> Tm70 g (arr70 a B) -> Tm70 g a -> Tm70 g B
app70 = \ t, u, tm, var70, lam70, app70 => app70 _ _ _ (t tm var70 lam70 app70) (u tm var70 lam70 app70)

v070 : {g:_}->{a:_} -> Tm70 (snoc70 g a) a
v070 = var70 vz70

v170 : {g:_}->{a:_}-> {B:_}-> Tm70 (snoc70 (snoc70 g a) B) a
v170 = var70 (vs70 vz70)

v270 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm70 (snoc70 (snoc70 (snoc70 g a) B) C) a
v270 = var70 (vs70 (vs70 vz70))

v370 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm70 (snoc70 (snoc70 (snoc70 (snoc70 g a) B) C) D) a
v370 = var70 (vs70 (vs70 (vs70 vz70)))

v470 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm70 (snoc70 (snoc70 (snoc70 (snoc70 (snoc70 g a) B) C) D) E) a
v470 = var70 (vs70 (vs70 (vs70 (vs70 vz70))))

test70 : {g:_}-> {a:_} -> Tm70 g (arr70 (arr70 a a) (arr70 a a))
test70  = lam70 (lam70 (app70 v170 (app70 v170 (app70 v170 (app70 v170 (app70 v170 (app70 v170 v070)))))))
Ty71 : Type
Ty71 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty71 : Ty71
empty71 = \ _, empty, _ => empty

arr71 : Ty71 -> Ty71 -> Ty71
arr71 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con71 : Type
Con71 = (Con71 : Type)
 ->(nil  : Con71)
 ->(snoc : Con71 -> Ty71 -> Con71)
 -> Con71

nil71 : Con71
nil71 = \ con, nil71, snoc => nil71

snoc71 : Con71 -> Ty71 -> Con71
snoc71 = \ g, a, con, nil71, snoc71 => snoc71 (g con nil71 snoc71) a

Var71 : Con71 -> Ty71 -> Type
Var71 = \ g, a =>
    (Var71 : Con71 -> Ty71 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var71 (snoc71 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var71 g a -> Var71 (snoc71 g b) a)
 -> Var71 g a

vz71 : {g : _}-> {a : _} -> Var71 (snoc71 g a) a
vz71 = \ var, vz71, vs => vz71 _ _

vs71 : {g : _} -> {B : _} -> {a : _} -> Var71 g a -> Var71 (snoc71 g B) a
vs71 = \ x, var, vz71, vs71 => vs71 _ _ _ (x var vz71 vs71)

Tm71 : Con71 -> Ty71 -> Type
Tm71 = \ g, a =>
    (Tm71    : Con71 -> Ty71 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var71 g a -> Tm71 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm71 (snoc71 g a) B -> Tm71 g (arr71 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm71 g (arr71 a B) -> Tm71 g a -> Tm71 g B)
 -> Tm71 g a

var71 : {g : _} -> {a : _} -> Var71 g a -> Tm71 g a
var71 = \ x, tm, var71, lam, app => var71 _ _ x

lam71 : {g : _} -> {a : _} -> {B : _} -> Tm71 (snoc71 g a) B -> Tm71 g (arr71 a B)
lam71 = \ t, tm, var71, lam71, app => lam71 _ _ _ (t tm var71 lam71 app)

app71 : {g:_}->{a:_}->{B:_} -> Tm71 g (arr71 a B) -> Tm71 g a -> Tm71 g B
app71 = \ t, u, tm, var71, lam71, app71 => app71 _ _ _ (t tm var71 lam71 app71) (u tm var71 lam71 app71)

v071 : {g:_}->{a:_} -> Tm71 (snoc71 g a) a
v071 = var71 vz71

v171 : {g:_}->{a:_}-> {B:_}-> Tm71 (snoc71 (snoc71 g a) B) a
v171 = var71 (vs71 vz71)

v271 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm71 (snoc71 (snoc71 (snoc71 g a) B) C) a
v271 = var71 (vs71 (vs71 vz71))

v371 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm71 (snoc71 (snoc71 (snoc71 (snoc71 g a) B) C) D) a
v371 = var71 (vs71 (vs71 (vs71 vz71)))

v471 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm71 (snoc71 (snoc71 (snoc71 (snoc71 (snoc71 g a) B) C) D) E) a
v471 = var71 (vs71 (vs71 (vs71 (vs71 vz71))))

test71 : {g:_}-> {a:_} -> Tm71 g (arr71 (arr71 a a) (arr71 a a))
test71  = lam71 (lam71 (app71 v171 (app71 v171 (app71 v171 (app71 v171 (app71 v171 (app71 v171 v071)))))))
Ty72 : Type
Ty72 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty72 : Ty72
empty72 = \ _, empty, _ => empty

arr72 : Ty72 -> Ty72 -> Ty72
arr72 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con72 : Type
Con72 = (Con72 : Type)
 ->(nil  : Con72)
 ->(snoc : Con72 -> Ty72 -> Con72)
 -> Con72

nil72 : Con72
nil72 = \ con, nil72, snoc => nil72

snoc72 : Con72 -> Ty72 -> Con72
snoc72 = \ g, a, con, nil72, snoc72 => snoc72 (g con nil72 snoc72) a

Var72 : Con72 -> Ty72 -> Type
Var72 = \ g, a =>
    (Var72 : Con72 -> Ty72 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var72 (snoc72 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var72 g a -> Var72 (snoc72 g b) a)
 -> Var72 g a

vz72 : {g : _}-> {a : _} -> Var72 (snoc72 g a) a
vz72 = \ var, vz72, vs => vz72 _ _

vs72 : {g : _} -> {B : _} -> {a : _} -> Var72 g a -> Var72 (snoc72 g B) a
vs72 = \ x, var, vz72, vs72 => vs72 _ _ _ (x var vz72 vs72)

Tm72 : Con72 -> Ty72 -> Type
Tm72 = \ g, a =>
    (Tm72    : Con72 -> Ty72 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var72 g a -> Tm72 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm72 (snoc72 g a) B -> Tm72 g (arr72 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm72 g (arr72 a B) -> Tm72 g a -> Tm72 g B)
 -> Tm72 g a

var72 : {g : _} -> {a : _} -> Var72 g a -> Tm72 g a
var72 = \ x, tm, var72, lam, app => var72 _ _ x

lam72 : {g : _} -> {a : _} -> {B : _} -> Tm72 (snoc72 g a) B -> Tm72 g (arr72 a B)
lam72 = \ t, tm, var72, lam72, app => lam72 _ _ _ (t tm var72 lam72 app)

app72 : {g:_}->{a:_}->{B:_} -> Tm72 g (arr72 a B) -> Tm72 g a -> Tm72 g B
app72 = \ t, u, tm, var72, lam72, app72 => app72 _ _ _ (t tm var72 lam72 app72) (u tm var72 lam72 app72)

v072 : {g:_}->{a:_} -> Tm72 (snoc72 g a) a
v072 = var72 vz72

v172 : {g:_}->{a:_}-> {B:_}-> Tm72 (snoc72 (snoc72 g a) B) a
v172 = var72 (vs72 vz72)

v272 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm72 (snoc72 (snoc72 (snoc72 g a) B) C) a
v272 = var72 (vs72 (vs72 vz72))

v372 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm72 (snoc72 (snoc72 (snoc72 (snoc72 g a) B) C) D) a
v372 = var72 (vs72 (vs72 (vs72 vz72)))

v472 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm72 (snoc72 (snoc72 (snoc72 (snoc72 (snoc72 g a) B) C) D) E) a
v472 = var72 (vs72 (vs72 (vs72 (vs72 vz72))))

test72 : {g:_}-> {a:_} -> Tm72 g (arr72 (arr72 a a) (arr72 a a))
test72  = lam72 (lam72 (app72 v172 (app72 v172 (app72 v172 (app72 v172 (app72 v172 (app72 v172 v072)))))))
Ty73 : Type
Ty73 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty73 : Ty73
empty73 = \ _, empty, _ => empty

arr73 : Ty73 -> Ty73 -> Ty73
arr73 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con73 : Type
Con73 = (Con73 : Type)
 ->(nil  : Con73)
 ->(snoc : Con73 -> Ty73 -> Con73)
 -> Con73

nil73 : Con73
nil73 = \ con, nil73, snoc => nil73

snoc73 : Con73 -> Ty73 -> Con73
snoc73 = \ g, a, con, nil73, snoc73 => snoc73 (g con nil73 snoc73) a

Var73 : Con73 -> Ty73 -> Type
Var73 = \ g, a =>
    (Var73 : Con73 -> Ty73 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var73 (snoc73 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var73 g a -> Var73 (snoc73 g b) a)
 -> Var73 g a

vz73 : {g : _}-> {a : _} -> Var73 (snoc73 g a) a
vz73 = \ var, vz73, vs => vz73 _ _

vs73 : {g : _} -> {B : _} -> {a : _} -> Var73 g a -> Var73 (snoc73 g B) a
vs73 = \ x, var, vz73, vs73 => vs73 _ _ _ (x var vz73 vs73)

Tm73 : Con73 -> Ty73 -> Type
Tm73 = \ g, a =>
    (Tm73    : Con73 -> Ty73 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var73 g a -> Tm73 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm73 (snoc73 g a) B -> Tm73 g (arr73 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm73 g (arr73 a B) -> Tm73 g a -> Tm73 g B)
 -> Tm73 g a

var73 : {g : _} -> {a : _} -> Var73 g a -> Tm73 g a
var73 = \ x, tm, var73, lam, app => var73 _ _ x

lam73 : {g : _} -> {a : _} -> {B : _} -> Tm73 (snoc73 g a) B -> Tm73 g (arr73 a B)
lam73 = \ t, tm, var73, lam73, app => lam73 _ _ _ (t tm var73 lam73 app)

app73 : {g:_}->{a:_}->{B:_} -> Tm73 g (arr73 a B) -> Tm73 g a -> Tm73 g B
app73 = \ t, u, tm, var73, lam73, app73 => app73 _ _ _ (t tm var73 lam73 app73) (u tm var73 lam73 app73)

v073 : {g:_}->{a:_} -> Tm73 (snoc73 g a) a
v073 = var73 vz73

v173 : {g:_}->{a:_}-> {B:_}-> Tm73 (snoc73 (snoc73 g a) B) a
v173 = var73 (vs73 vz73)

v273 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm73 (snoc73 (snoc73 (snoc73 g a) B) C) a
v273 = var73 (vs73 (vs73 vz73))

v373 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm73 (snoc73 (snoc73 (snoc73 (snoc73 g a) B) C) D) a
v373 = var73 (vs73 (vs73 (vs73 vz73)))

v473 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm73 (snoc73 (snoc73 (snoc73 (snoc73 (snoc73 g a) B) C) D) E) a
v473 = var73 (vs73 (vs73 (vs73 (vs73 vz73))))

test73 : {g:_}-> {a:_} -> Tm73 g (arr73 (arr73 a a) (arr73 a a))
test73  = lam73 (lam73 (app73 v173 (app73 v173 (app73 v173 (app73 v173 (app73 v173 (app73 v173 v073)))))))
Ty74 : Type
Ty74 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty74 : Ty74
empty74 = \ _, empty, _ => empty

arr74 : Ty74 -> Ty74 -> Ty74
arr74 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con74 : Type
Con74 = (Con74 : Type)
 ->(nil  : Con74)
 ->(snoc : Con74 -> Ty74 -> Con74)
 -> Con74

nil74 : Con74
nil74 = \ con, nil74, snoc => nil74

snoc74 : Con74 -> Ty74 -> Con74
snoc74 = \ g, a, con, nil74, snoc74 => snoc74 (g con nil74 snoc74) a

Var74 : Con74 -> Ty74 -> Type
Var74 = \ g, a =>
    (Var74 : Con74 -> Ty74 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var74 (snoc74 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var74 g a -> Var74 (snoc74 g b) a)
 -> Var74 g a

vz74 : {g : _}-> {a : _} -> Var74 (snoc74 g a) a
vz74 = \ var, vz74, vs => vz74 _ _

vs74 : {g : _} -> {B : _} -> {a : _} -> Var74 g a -> Var74 (snoc74 g B) a
vs74 = \ x, var, vz74, vs74 => vs74 _ _ _ (x var vz74 vs74)

Tm74 : Con74 -> Ty74 -> Type
Tm74 = \ g, a =>
    (Tm74    : Con74 -> Ty74 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var74 g a -> Tm74 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm74 (snoc74 g a) B -> Tm74 g (arr74 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm74 g (arr74 a B) -> Tm74 g a -> Tm74 g B)
 -> Tm74 g a

var74 : {g : _} -> {a : _} -> Var74 g a -> Tm74 g a
var74 = \ x, tm, var74, lam, app => var74 _ _ x

lam74 : {g : _} -> {a : _} -> {B : _} -> Tm74 (snoc74 g a) B -> Tm74 g (arr74 a B)
lam74 = \ t, tm, var74, lam74, app => lam74 _ _ _ (t tm var74 lam74 app)

app74 : {g:_}->{a:_}->{B:_} -> Tm74 g (arr74 a B) -> Tm74 g a -> Tm74 g B
app74 = \ t, u, tm, var74, lam74, app74 => app74 _ _ _ (t tm var74 lam74 app74) (u tm var74 lam74 app74)

v074 : {g:_}->{a:_} -> Tm74 (snoc74 g a) a
v074 = var74 vz74

v174 : {g:_}->{a:_}-> {B:_}-> Tm74 (snoc74 (snoc74 g a) B) a
v174 = var74 (vs74 vz74)

v274 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm74 (snoc74 (snoc74 (snoc74 g a) B) C) a
v274 = var74 (vs74 (vs74 vz74))

v374 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm74 (snoc74 (snoc74 (snoc74 (snoc74 g a) B) C) D) a
v374 = var74 (vs74 (vs74 (vs74 vz74)))

v474 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm74 (snoc74 (snoc74 (snoc74 (snoc74 (snoc74 g a) B) C) D) E) a
v474 = var74 (vs74 (vs74 (vs74 (vs74 vz74))))

test74 : {g:_}-> {a:_} -> Tm74 g (arr74 (arr74 a a) (arr74 a a))
test74  = lam74 (lam74 (app74 v174 (app74 v174 (app74 v174 (app74 v174 (app74 v174 (app74 v174 v074)))))))
Ty75 : Type
Ty75 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty75 : Ty75
empty75 = \ _, empty, _ => empty

arr75 : Ty75 -> Ty75 -> Ty75
arr75 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con75 : Type
Con75 = (Con75 : Type)
 ->(nil  : Con75)
 ->(snoc : Con75 -> Ty75 -> Con75)
 -> Con75

nil75 : Con75
nil75 = \ con, nil75, snoc => nil75

snoc75 : Con75 -> Ty75 -> Con75
snoc75 = \ g, a, con, nil75, snoc75 => snoc75 (g con nil75 snoc75) a

Var75 : Con75 -> Ty75 -> Type
Var75 = \ g, a =>
    (Var75 : Con75 -> Ty75 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var75 (snoc75 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var75 g a -> Var75 (snoc75 g b) a)
 -> Var75 g a

vz75 : {g : _}-> {a : _} -> Var75 (snoc75 g a) a
vz75 = \ var, vz75, vs => vz75 _ _

vs75 : {g : _} -> {B : _} -> {a : _} -> Var75 g a -> Var75 (snoc75 g B) a
vs75 = \ x, var, vz75, vs75 => vs75 _ _ _ (x var vz75 vs75)

Tm75 : Con75 -> Ty75 -> Type
Tm75 = \ g, a =>
    (Tm75    : Con75 -> Ty75 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var75 g a -> Tm75 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm75 (snoc75 g a) B -> Tm75 g (arr75 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm75 g (arr75 a B) -> Tm75 g a -> Tm75 g B)
 -> Tm75 g a

var75 : {g : _} -> {a : _} -> Var75 g a -> Tm75 g a
var75 = \ x, tm, var75, lam, app => var75 _ _ x

lam75 : {g : _} -> {a : _} -> {B : _} -> Tm75 (snoc75 g a) B -> Tm75 g (arr75 a B)
lam75 = \ t, tm, var75, lam75, app => lam75 _ _ _ (t tm var75 lam75 app)

app75 : {g:_}->{a:_}->{B:_} -> Tm75 g (arr75 a B) -> Tm75 g a -> Tm75 g B
app75 = \ t, u, tm, var75, lam75, app75 => app75 _ _ _ (t tm var75 lam75 app75) (u tm var75 lam75 app75)

v075 : {g:_}->{a:_} -> Tm75 (snoc75 g a) a
v075 = var75 vz75

v175 : {g:_}->{a:_}-> {B:_}-> Tm75 (snoc75 (snoc75 g a) B) a
v175 = var75 (vs75 vz75)

v275 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm75 (snoc75 (snoc75 (snoc75 g a) B) C) a
v275 = var75 (vs75 (vs75 vz75))

v375 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm75 (snoc75 (snoc75 (snoc75 (snoc75 g a) B) C) D) a
v375 = var75 (vs75 (vs75 (vs75 vz75)))

v475 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm75 (snoc75 (snoc75 (snoc75 (snoc75 (snoc75 g a) B) C) D) E) a
v475 = var75 (vs75 (vs75 (vs75 (vs75 vz75))))

test75 : {g:_}-> {a:_} -> Tm75 g (arr75 (arr75 a a) (arr75 a a))
test75  = lam75 (lam75 (app75 v175 (app75 v175 (app75 v175 (app75 v175 (app75 v175 (app75 v175 v075)))))))
Ty76 : Type
Ty76 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty76 : Ty76
empty76 = \ _, empty, _ => empty

arr76 : Ty76 -> Ty76 -> Ty76
arr76 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con76 : Type
Con76 = (Con76 : Type)
 ->(nil  : Con76)
 ->(snoc : Con76 -> Ty76 -> Con76)
 -> Con76

nil76 : Con76
nil76 = \ con, nil76, snoc => nil76

snoc76 : Con76 -> Ty76 -> Con76
snoc76 = \ g, a, con, nil76, snoc76 => snoc76 (g con nil76 snoc76) a

Var76 : Con76 -> Ty76 -> Type
Var76 = \ g, a =>
    (Var76 : Con76 -> Ty76 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var76 (snoc76 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var76 g a -> Var76 (snoc76 g b) a)
 -> Var76 g a

vz76 : {g : _}-> {a : _} -> Var76 (snoc76 g a) a
vz76 = \ var, vz76, vs => vz76 _ _

vs76 : {g : _} -> {B : _} -> {a : _} -> Var76 g a -> Var76 (snoc76 g B) a
vs76 = \ x, var, vz76, vs76 => vs76 _ _ _ (x var vz76 vs76)

Tm76 : Con76 -> Ty76 -> Type
Tm76 = \ g, a =>
    (Tm76    : Con76 -> Ty76 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var76 g a -> Tm76 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm76 (snoc76 g a) B -> Tm76 g (arr76 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm76 g (arr76 a B) -> Tm76 g a -> Tm76 g B)
 -> Tm76 g a

var76 : {g : _} -> {a : _} -> Var76 g a -> Tm76 g a
var76 = \ x, tm, var76, lam, app => var76 _ _ x

lam76 : {g : _} -> {a : _} -> {B : _} -> Tm76 (snoc76 g a) B -> Tm76 g (arr76 a B)
lam76 = \ t, tm, var76, lam76, app => lam76 _ _ _ (t tm var76 lam76 app)

app76 : {g:_}->{a:_}->{B:_} -> Tm76 g (arr76 a B) -> Tm76 g a -> Tm76 g B
app76 = \ t, u, tm, var76, lam76, app76 => app76 _ _ _ (t tm var76 lam76 app76) (u tm var76 lam76 app76)

v076 : {g:_}->{a:_} -> Tm76 (snoc76 g a) a
v076 = var76 vz76

v176 : {g:_}->{a:_}-> {B:_}-> Tm76 (snoc76 (snoc76 g a) B) a
v176 = var76 (vs76 vz76)

v276 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm76 (snoc76 (snoc76 (snoc76 g a) B) C) a
v276 = var76 (vs76 (vs76 vz76))

v376 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm76 (snoc76 (snoc76 (snoc76 (snoc76 g a) B) C) D) a
v376 = var76 (vs76 (vs76 (vs76 vz76)))

v476 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm76 (snoc76 (snoc76 (snoc76 (snoc76 (snoc76 g a) B) C) D) E) a
v476 = var76 (vs76 (vs76 (vs76 (vs76 vz76))))

test76 : {g:_}-> {a:_} -> Tm76 g (arr76 (arr76 a a) (arr76 a a))
test76  = lam76 (lam76 (app76 v176 (app76 v176 (app76 v176 (app76 v176 (app76 v176 (app76 v176 v076)))))))
Ty77 : Type
Ty77 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty77 : Ty77
empty77 = \ _, empty, _ => empty

arr77 : Ty77 -> Ty77 -> Ty77
arr77 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con77 : Type
Con77 = (Con77 : Type)
 ->(nil  : Con77)
 ->(snoc : Con77 -> Ty77 -> Con77)
 -> Con77

nil77 : Con77
nil77 = \ con, nil77, snoc => nil77

snoc77 : Con77 -> Ty77 -> Con77
snoc77 = \ g, a, con, nil77, snoc77 => snoc77 (g con nil77 snoc77) a

Var77 : Con77 -> Ty77 -> Type
Var77 = \ g, a =>
    (Var77 : Con77 -> Ty77 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var77 (snoc77 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var77 g a -> Var77 (snoc77 g b) a)
 -> Var77 g a

vz77 : {g : _}-> {a : _} -> Var77 (snoc77 g a) a
vz77 = \ var, vz77, vs => vz77 _ _

vs77 : {g : _} -> {B : _} -> {a : _} -> Var77 g a -> Var77 (snoc77 g B) a
vs77 = \ x, var, vz77, vs77 => vs77 _ _ _ (x var vz77 vs77)

Tm77 : Con77 -> Ty77 -> Type
Tm77 = \ g, a =>
    (Tm77    : Con77 -> Ty77 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var77 g a -> Tm77 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm77 (snoc77 g a) B -> Tm77 g (arr77 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm77 g (arr77 a B) -> Tm77 g a -> Tm77 g B)
 -> Tm77 g a

var77 : {g : _} -> {a : _} -> Var77 g a -> Tm77 g a
var77 = \ x, tm, var77, lam, app => var77 _ _ x

lam77 : {g : _} -> {a : _} -> {B : _} -> Tm77 (snoc77 g a) B -> Tm77 g (arr77 a B)
lam77 = \ t, tm, var77, lam77, app => lam77 _ _ _ (t tm var77 lam77 app)

app77 : {g:_}->{a:_}->{B:_} -> Tm77 g (arr77 a B) -> Tm77 g a -> Tm77 g B
app77 = \ t, u, tm, var77, lam77, app77 => app77 _ _ _ (t tm var77 lam77 app77) (u tm var77 lam77 app77)

v077 : {g:_}->{a:_} -> Tm77 (snoc77 g a) a
v077 = var77 vz77

v177 : {g:_}->{a:_}-> {B:_}-> Tm77 (snoc77 (snoc77 g a) B) a
v177 = var77 (vs77 vz77)

v277 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm77 (snoc77 (snoc77 (snoc77 g a) B) C) a
v277 = var77 (vs77 (vs77 vz77))

v377 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm77 (snoc77 (snoc77 (snoc77 (snoc77 g a) B) C) D) a
v377 = var77 (vs77 (vs77 (vs77 vz77)))

v477 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm77 (snoc77 (snoc77 (snoc77 (snoc77 (snoc77 g a) B) C) D) E) a
v477 = var77 (vs77 (vs77 (vs77 (vs77 vz77))))

test77 : {g:_}-> {a:_} -> Tm77 g (arr77 (arr77 a a) (arr77 a a))
test77  = lam77 (lam77 (app77 v177 (app77 v177 (app77 v177 (app77 v177 (app77 v177 (app77 v177 v077)))))))
Ty78 : Type
Ty78 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty78 : Ty78
empty78 = \ _, empty, _ => empty

arr78 : Ty78 -> Ty78 -> Ty78
arr78 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con78 : Type
Con78 = (Con78 : Type)
 ->(nil  : Con78)
 ->(snoc : Con78 -> Ty78 -> Con78)
 -> Con78

nil78 : Con78
nil78 = \ con, nil78, snoc => nil78

snoc78 : Con78 -> Ty78 -> Con78
snoc78 = \ g, a, con, nil78, snoc78 => snoc78 (g con nil78 snoc78) a

Var78 : Con78 -> Ty78 -> Type
Var78 = \ g, a =>
    (Var78 : Con78 -> Ty78 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var78 (snoc78 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var78 g a -> Var78 (snoc78 g b) a)
 -> Var78 g a

vz78 : {g : _}-> {a : _} -> Var78 (snoc78 g a) a
vz78 = \ var, vz78, vs => vz78 _ _

vs78 : {g : _} -> {B : _} -> {a : _} -> Var78 g a -> Var78 (snoc78 g B) a
vs78 = \ x, var, vz78, vs78 => vs78 _ _ _ (x var vz78 vs78)

Tm78 : Con78 -> Ty78 -> Type
Tm78 = \ g, a =>
    (Tm78    : Con78 -> Ty78 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var78 g a -> Tm78 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm78 (snoc78 g a) B -> Tm78 g (arr78 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm78 g (arr78 a B) -> Tm78 g a -> Tm78 g B)
 -> Tm78 g a

var78 : {g : _} -> {a : _} -> Var78 g a -> Tm78 g a
var78 = \ x, tm, var78, lam, app => var78 _ _ x

lam78 : {g : _} -> {a : _} -> {B : _} -> Tm78 (snoc78 g a) B -> Tm78 g (arr78 a B)
lam78 = \ t, tm, var78, lam78, app => lam78 _ _ _ (t tm var78 lam78 app)

app78 : {g:_}->{a:_}->{B:_} -> Tm78 g (arr78 a B) -> Tm78 g a -> Tm78 g B
app78 = \ t, u, tm, var78, lam78, app78 => app78 _ _ _ (t tm var78 lam78 app78) (u tm var78 lam78 app78)

v078 : {g:_}->{a:_} -> Tm78 (snoc78 g a) a
v078 = var78 vz78

v178 : {g:_}->{a:_}-> {B:_}-> Tm78 (snoc78 (snoc78 g a) B) a
v178 = var78 (vs78 vz78)

v278 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm78 (snoc78 (snoc78 (snoc78 g a) B) C) a
v278 = var78 (vs78 (vs78 vz78))

v378 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm78 (snoc78 (snoc78 (snoc78 (snoc78 g a) B) C) D) a
v378 = var78 (vs78 (vs78 (vs78 vz78)))

v478 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm78 (snoc78 (snoc78 (snoc78 (snoc78 (snoc78 g a) B) C) D) E) a
v478 = var78 (vs78 (vs78 (vs78 (vs78 vz78))))

test78 : {g:_}-> {a:_} -> Tm78 g (arr78 (arr78 a a) (arr78 a a))
test78  = lam78 (lam78 (app78 v178 (app78 v178 (app78 v178 (app78 v178 (app78 v178 (app78 v178 v078)))))))
Ty79 : Type
Ty79 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty79 : Ty79
empty79 = \ _, empty, _ => empty

arr79 : Ty79 -> Ty79 -> Ty79
arr79 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con79 : Type
Con79 = (Con79 : Type)
 ->(nil  : Con79)
 ->(snoc : Con79 -> Ty79 -> Con79)
 -> Con79

nil79 : Con79
nil79 = \ con, nil79, snoc => nil79

snoc79 : Con79 -> Ty79 -> Con79
snoc79 = \ g, a, con, nil79, snoc79 => snoc79 (g con nil79 snoc79) a

Var79 : Con79 -> Ty79 -> Type
Var79 = \ g, a =>
    (Var79 : Con79 -> Ty79 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var79 (snoc79 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var79 g a -> Var79 (snoc79 g b) a)
 -> Var79 g a

vz79 : {g : _}-> {a : _} -> Var79 (snoc79 g a) a
vz79 = \ var, vz79, vs => vz79 _ _

vs79 : {g : _} -> {B : _} -> {a : _} -> Var79 g a -> Var79 (snoc79 g B) a
vs79 = \ x, var, vz79, vs79 => vs79 _ _ _ (x var vz79 vs79)

Tm79 : Con79 -> Ty79 -> Type
Tm79 = \ g, a =>
    (Tm79    : Con79 -> Ty79 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var79 g a -> Tm79 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm79 (snoc79 g a) B -> Tm79 g (arr79 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm79 g (arr79 a B) -> Tm79 g a -> Tm79 g B)
 -> Tm79 g a

var79 : {g : _} -> {a : _} -> Var79 g a -> Tm79 g a
var79 = \ x, tm, var79, lam, app => var79 _ _ x

lam79 : {g : _} -> {a : _} -> {B : _} -> Tm79 (snoc79 g a) B -> Tm79 g (arr79 a B)
lam79 = \ t, tm, var79, lam79, app => lam79 _ _ _ (t tm var79 lam79 app)

app79 : {g:_}->{a:_}->{B:_} -> Tm79 g (arr79 a B) -> Tm79 g a -> Tm79 g B
app79 = \ t, u, tm, var79, lam79, app79 => app79 _ _ _ (t tm var79 lam79 app79) (u tm var79 lam79 app79)

v079 : {g:_}->{a:_} -> Tm79 (snoc79 g a) a
v079 = var79 vz79

v179 : {g:_}->{a:_}-> {B:_}-> Tm79 (snoc79 (snoc79 g a) B) a
v179 = var79 (vs79 vz79)

v279 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm79 (snoc79 (snoc79 (snoc79 g a) B) C) a
v279 = var79 (vs79 (vs79 vz79))

v379 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm79 (snoc79 (snoc79 (snoc79 (snoc79 g a) B) C) D) a
v379 = var79 (vs79 (vs79 (vs79 vz79)))

v479 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm79 (snoc79 (snoc79 (snoc79 (snoc79 (snoc79 g a) B) C) D) E) a
v479 = var79 (vs79 (vs79 (vs79 (vs79 vz79))))

test79 : {g:_}-> {a:_} -> Tm79 g (arr79 (arr79 a a) (arr79 a a))
test79  = lam79 (lam79 (app79 v179 (app79 v179 (app79 v179 (app79 v179 (app79 v179 (app79 v179 v079)))))))
Ty80 : Type
Ty80 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty80 : Ty80
empty80 = \ _, empty, _ => empty

arr80 : Ty80 -> Ty80 -> Ty80
arr80 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con80 : Type
Con80 = (Con80 : Type)
 ->(nil  : Con80)
 ->(snoc : Con80 -> Ty80 -> Con80)
 -> Con80

nil80 : Con80
nil80 = \ con, nil80, snoc => nil80

snoc80 : Con80 -> Ty80 -> Con80
snoc80 = \ g, a, con, nil80, snoc80 => snoc80 (g con nil80 snoc80) a

Var80 : Con80 -> Ty80 -> Type
Var80 = \ g, a =>
    (Var80 : Con80 -> Ty80 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var80 (snoc80 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var80 g a -> Var80 (snoc80 g b) a)
 -> Var80 g a

vz80 : {g : _}-> {a : _} -> Var80 (snoc80 g a) a
vz80 = \ var, vz80, vs => vz80 _ _

vs80 : {g : _} -> {B : _} -> {a : _} -> Var80 g a -> Var80 (snoc80 g B) a
vs80 = \ x, var, vz80, vs80 => vs80 _ _ _ (x var vz80 vs80)

Tm80 : Con80 -> Ty80 -> Type
Tm80 = \ g, a =>
    (Tm80    : Con80 -> Ty80 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var80 g a -> Tm80 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm80 (snoc80 g a) B -> Tm80 g (arr80 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm80 g (arr80 a B) -> Tm80 g a -> Tm80 g B)
 -> Tm80 g a

var80 : {g : _} -> {a : _} -> Var80 g a -> Tm80 g a
var80 = \ x, tm, var80, lam, app => var80 _ _ x

lam80 : {g : _} -> {a : _} -> {B : _} -> Tm80 (snoc80 g a) B -> Tm80 g (arr80 a B)
lam80 = \ t, tm, var80, lam80, app => lam80 _ _ _ (t tm var80 lam80 app)

app80 : {g:_}->{a:_}->{B:_} -> Tm80 g (arr80 a B) -> Tm80 g a -> Tm80 g B
app80 = \ t, u, tm, var80, lam80, app80 => app80 _ _ _ (t tm var80 lam80 app80) (u tm var80 lam80 app80)

v080 : {g:_}->{a:_} -> Tm80 (snoc80 g a) a
v080 = var80 vz80

v180 : {g:_}->{a:_}-> {B:_}-> Tm80 (snoc80 (snoc80 g a) B) a
v180 = var80 (vs80 vz80)

v280 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm80 (snoc80 (snoc80 (snoc80 g a) B) C) a
v280 = var80 (vs80 (vs80 vz80))

v380 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm80 (snoc80 (snoc80 (snoc80 (snoc80 g a) B) C) D) a
v380 = var80 (vs80 (vs80 (vs80 vz80)))

v480 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm80 (snoc80 (snoc80 (snoc80 (snoc80 (snoc80 g a) B) C) D) E) a
v480 = var80 (vs80 (vs80 (vs80 (vs80 vz80))))

test80 : {g:_}-> {a:_} -> Tm80 g (arr80 (arr80 a a) (arr80 a a))
test80  = lam80 (lam80 (app80 v180 (app80 v180 (app80 v180 (app80 v180 (app80 v180 (app80 v180 v080)))))))
Ty81 : Type
Ty81 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty81 : Ty81
empty81 = \ _, empty, _ => empty

arr81 : Ty81 -> Ty81 -> Ty81
arr81 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con81 : Type
Con81 = (Con81 : Type)
 ->(nil  : Con81)
 ->(snoc : Con81 -> Ty81 -> Con81)
 -> Con81

nil81 : Con81
nil81 = \ con, nil81, snoc => nil81

snoc81 : Con81 -> Ty81 -> Con81
snoc81 = \ g, a, con, nil81, snoc81 => snoc81 (g con nil81 snoc81) a

Var81 : Con81 -> Ty81 -> Type
Var81 = \ g, a =>
    (Var81 : Con81 -> Ty81 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var81 (snoc81 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var81 g a -> Var81 (snoc81 g b) a)
 -> Var81 g a

vz81 : {g : _}-> {a : _} -> Var81 (snoc81 g a) a
vz81 = \ var, vz81, vs => vz81 _ _

vs81 : {g : _} -> {B : _} -> {a : _} -> Var81 g a -> Var81 (snoc81 g B) a
vs81 = \ x, var, vz81, vs81 => vs81 _ _ _ (x var vz81 vs81)

Tm81 : Con81 -> Ty81 -> Type
Tm81 = \ g, a =>
    (Tm81    : Con81 -> Ty81 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var81 g a -> Tm81 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm81 (snoc81 g a) B -> Tm81 g (arr81 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm81 g (arr81 a B) -> Tm81 g a -> Tm81 g B)
 -> Tm81 g a

var81 : {g : _} -> {a : _} -> Var81 g a -> Tm81 g a
var81 = \ x, tm, var81, lam, app => var81 _ _ x

lam81 : {g : _} -> {a : _} -> {B : _} -> Tm81 (snoc81 g a) B -> Tm81 g (arr81 a B)
lam81 = \ t, tm, var81, lam81, app => lam81 _ _ _ (t tm var81 lam81 app)

app81 : {g:_}->{a:_}->{B:_} -> Tm81 g (arr81 a B) -> Tm81 g a -> Tm81 g B
app81 = \ t, u, tm, var81, lam81, app81 => app81 _ _ _ (t tm var81 lam81 app81) (u tm var81 lam81 app81)

v081 : {g:_}->{a:_} -> Tm81 (snoc81 g a) a
v081 = var81 vz81

v181 : {g:_}->{a:_}-> {B:_}-> Tm81 (snoc81 (snoc81 g a) B) a
v181 = var81 (vs81 vz81)

v281 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm81 (snoc81 (snoc81 (snoc81 g a) B) C) a
v281 = var81 (vs81 (vs81 vz81))

v381 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm81 (snoc81 (snoc81 (snoc81 (snoc81 g a) B) C) D) a
v381 = var81 (vs81 (vs81 (vs81 vz81)))

v481 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm81 (snoc81 (snoc81 (snoc81 (snoc81 (snoc81 g a) B) C) D) E) a
v481 = var81 (vs81 (vs81 (vs81 (vs81 vz81))))

test81 : {g:_}-> {a:_} -> Tm81 g (arr81 (arr81 a a) (arr81 a a))
test81  = lam81 (lam81 (app81 v181 (app81 v181 (app81 v181 (app81 v181 (app81 v181 (app81 v181 v081)))))))
Ty82 : Type
Ty82 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty82 : Ty82
empty82 = \ _, empty, _ => empty

arr82 : Ty82 -> Ty82 -> Ty82
arr82 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con82 : Type
Con82 = (Con82 : Type)
 ->(nil  : Con82)
 ->(snoc : Con82 -> Ty82 -> Con82)
 -> Con82

nil82 : Con82
nil82 = \ con, nil82, snoc => nil82

snoc82 : Con82 -> Ty82 -> Con82
snoc82 = \ g, a, con, nil82, snoc82 => snoc82 (g con nil82 snoc82) a

Var82 : Con82 -> Ty82 -> Type
Var82 = \ g, a =>
    (Var82 : Con82 -> Ty82 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var82 (snoc82 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var82 g a -> Var82 (snoc82 g b) a)
 -> Var82 g a

vz82 : {g : _}-> {a : _} -> Var82 (snoc82 g a) a
vz82 = \ var, vz82, vs => vz82 _ _

vs82 : {g : _} -> {B : _} -> {a : _} -> Var82 g a -> Var82 (snoc82 g B) a
vs82 = \ x, var, vz82, vs82 => vs82 _ _ _ (x var vz82 vs82)

Tm82 : Con82 -> Ty82 -> Type
Tm82 = \ g, a =>
    (Tm82    : Con82 -> Ty82 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var82 g a -> Tm82 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm82 (snoc82 g a) B -> Tm82 g (arr82 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm82 g (arr82 a B) -> Tm82 g a -> Tm82 g B)
 -> Tm82 g a

var82 : {g : _} -> {a : _} -> Var82 g a -> Tm82 g a
var82 = \ x, tm, var82, lam, app => var82 _ _ x

lam82 : {g : _} -> {a : _} -> {B : _} -> Tm82 (snoc82 g a) B -> Tm82 g (arr82 a B)
lam82 = \ t, tm, var82, lam82, app => lam82 _ _ _ (t tm var82 lam82 app)

app82 : {g:_}->{a:_}->{B:_} -> Tm82 g (arr82 a B) -> Tm82 g a -> Tm82 g B
app82 = \ t, u, tm, var82, lam82, app82 => app82 _ _ _ (t tm var82 lam82 app82) (u tm var82 lam82 app82)

v082 : {g:_}->{a:_} -> Tm82 (snoc82 g a) a
v082 = var82 vz82

v182 : {g:_}->{a:_}-> {B:_}-> Tm82 (snoc82 (snoc82 g a) B) a
v182 = var82 (vs82 vz82)

v282 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm82 (snoc82 (snoc82 (snoc82 g a) B) C) a
v282 = var82 (vs82 (vs82 vz82))

v382 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm82 (snoc82 (snoc82 (snoc82 (snoc82 g a) B) C) D) a
v382 = var82 (vs82 (vs82 (vs82 vz82)))

v482 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm82 (snoc82 (snoc82 (snoc82 (snoc82 (snoc82 g a) B) C) D) E) a
v482 = var82 (vs82 (vs82 (vs82 (vs82 vz82))))

test82 : {g:_}-> {a:_} -> Tm82 g (arr82 (arr82 a a) (arr82 a a))
test82  = lam82 (lam82 (app82 v182 (app82 v182 (app82 v182 (app82 v182 (app82 v182 (app82 v182 v082)))))))
Ty83 : Type
Ty83 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty83 : Ty83
empty83 = \ _, empty, _ => empty

arr83 : Ty83 -> Ty83 -> Ty83
arr83 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con83 : Type
Con83 = (Con83 : Type)
 ->(nil  : Con83)
 ->(snoc : Con83 -> Ty83 -> Con83)
 -> Con83

nil83 : Con83
nil83 = \ con, nil83, snoc => nil83

snoc83 : Con83 -> Ty83 -> Con83
snoc83 = \ g, a, con, nil83, snoc83 => snoc83 (g con nil83 snoc83) a

Var83 : Con83 -> Ty83 -> Type
Var83 = \ g, a =>
    (Var83 : Con83 -> Ty83 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var83 (snoc83 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var83 g a -> Var83 (snoc83 g b) a)
 -> Var83 g a

vz83 : {g : _}-> {a : _} -> Var83 (snoc83 g a) a
vz83 = \ var, vz83, vs => vz83 _ _

vs83 : {g : _} -> {B : _} -> {a : _} -> Var83 g a -> Var83 (snoc83 g B) a
vs83 = \ x, var, vz83, vs83 => vs83 _ _ _ (x var vz83 vs83)

Tm83 : Con83 -> Ty83 -> Type
Tm83 = \ g, a =>
    (Tm83    : Con83 -> Ty83 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var83 g a -> Tm83 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm83 (snoc83 g a) B -> Tm83 g (arr83 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm83 g (arr83 a B) -> Tm83 g a -> Tm83 g B)
 -> Tm83 g a

var83 : {g : _} -> {a : _} -> Var83 g a -> Tm83 g a
var83 = \ x, tm, var83, lam, app => var83 _ _ x

lam83 : {g : _} -> {a : _} -> {B : _} -> Tm83 (snoc83 g a) B -> Tm83 g (arr83 a B)
lam83 = \ t, tm, var83, lam83, app => lam83 _ _ _ (t tm var83 lam83 app)

app83 : {g:_}->{a:_}->{B:_} -> Tm83 g (arr83 a B) -> Tm83 g a -> Tm83 g B
app83 = \ t, u, tm, var83, lam83, app83 => app83 _ _ _ (t tm var83 lam83 app83) (u tm var83 lam83 app83)

v083 : {g:_}->{a:_} -> Tm83 (snoc83 g a) a
v083 = var83 vz83

v183 : {g:_}->{a:_}-> {B:_}-> Tm83 (snoc83 (snoc83 g a) B) a
v183 = var83 (vs83 vz83)

v283 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm83 (snoc83 (snoc83 (snoc83 g a) B) C) a
v283 = var83 (vs83 (vs83 vz83))

v383 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm83 (snoc83 (snoc83 (snoc83 (snoc83 g a) B) C) D) a
v383 = var83 (vs83 (vs83 (vs83 vz83)))

v483 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm83 (snoc83 (snoc83 (snoc83 (snoc83 (snoc83 g a) B) C) D) E) a
v483 = var83 (vs83 (vs83 (vs83 (vs83 vz83))))

test83 : {g:_}-> {a:_} -> Tm83 g (arr83 (arr83 a a) (arr83 a a))
test83  = lam83 (lam83 (app83 v183 (app83 v183 (app83 v183 (app83 v183 (app83 v183 (app83 v183 v083)))))))
Ty84 : Type
Ty84 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty84 : Ty84
empty84 = \ _, empty, _ => empty

arr84 : Ty84 -> Ty84 -> Ty84
arr84 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con84 : Type
Con84 = (Con84 : Type)
 ->(nil  : Con84)
 ->(snoc : Con84 -> Ty84 -> Con84)
 -> Con84

nil84 : Con84
nil84 = \ con, nil84, snoc => nil84

snoc84 : Con84 -> Ty84 -> Con84
snoc84 = \ g, a, con, nil84, snoc84 => snoc84 (g con nil84 snoc84) a

Var84 : Con84 -> Ty84 -> Type
Var84 = \ g, a =>
    (Var84 : Con84 -> Ty84 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var84 (snoc84 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var84 g a -> Var84 (snoc84 g b) a)
 -> Var84 g a

vz84 : {g : _}-> {a : _} -> Var84 (snoc84 g a) a
vz84 = \ var, vz84, vs => vz84 _ _

vs84 : {g : _} -> {B : _} -> {a : _} -> Var84 g a -> Var84 (snoc84 g B) a
vs84 = \ x, var, vz84, vs84 => vs84 _ _ _ (x var vz84 vs84)

Tm84 : Con84 -> Ty84 -> Type
Tm84 = \ g, a =>
    (Tm84    : Con84 -> Ty84 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var84 g a -> Tm84 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm84 (snoc84 g a) B -> Tm84 g (arr84 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm84 g (arr84 a B) -> Tm84 g a -> Tm84 g B)
 -> Tm84 g a

var84 : {g : _} -> {a : _} -> Var84 g a -> Tm84 g a
var84 = \ x, tm, var84, lam, app => var84 _ _ x

lam84 : {g : _} -> {a : _} -> {B : _} -> Tm84 (snoc84 g a) B -> Tm84 g (arr84 a B)
lam84 = \ t, tm, var84, lam84, app => lam84 _ _ _ (t tm var84 lam84 app)

app84 : {g:_}->{a:_}->{B:_} -> Tm84 g (arr84 a B) -> Tm84 g a -> Tm84 g B
app84 = \ t, u, tm, var84, lam84, app84 => app84 _ _ _ (t tm var84 lam84 app84) (u tm var84 lam84 app84)

v084 : {g:_}->{a:_} -> Tm84 (snoc84 g a) a
v084 = var84 vz84

v184 : {g:_}->{a:_}-> {B:_}-> Tm84 (snoc84 (snoc84 g a) B) a
v184 = var84 (vs84 vz84)

v284 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm84 (snoc84 (snoc84 (snoc84 g a) B) C) a
v284 = var84 (vs84 (vs84 vz84))

v384 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm84 (snoc84 (snoc84 (snoc84 (snoc84 g a) B) C) D) a
v384 = var84 (vs84 (vs84 (vs84 vz84)))

v484 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm84 (snoc84 (snoc84 (snoc84 (snoc84 (snoc84 g a) B) C) D) E) a
v484 = var84 (vs84 (vs84 (vs84 (vs84 vz84))))

test84 : {g:_}-> {a:_} -> Tm84 g (arr84 (arr84 a a) (arr84 a a))
test84  = lam84 (lam84 (app84 v184 (app84 v184 (app84 v184 (app84 v184 (app84 v184 (app84 v184 v084)))))))
Ty85 : Type
Ty85 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty85 : Ty85
empty85 = \ _, empty, _ => empty

arr85 : Ty85 -> Ty85 -> Ty85
arr85 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con85 : Type
Con85 = (Con85 : Type)
 ->(nil  : Con85)
 ->(snoc : Con85 -> Ty85 -> Con85)
 -> Con85

nil85 : Con85
nil85 = \ con, nil85, snoc => nil85

snoc85 : Con85 -> Ty85 -> Con85
snoc85 = \ g, a, con, nil85, snoc85 => snoc85 (g con nil85 snoc85) a

Var85 : Con85 -> Ty85 -> Type
Var85 = \ g, a =>
    (Var85 : Con85 -> Ty85 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var85 (snoc85 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var85 g a -> Var85 (snoc85 g b) a)
 -> Var85 g a

vz85 : {g : _}-> {a : _} -> Var85 (snoc85 g a) a
vz85 = \ var, vz85, vs => vz85 _ _

vs85 : {g : _} -> {B : _} -> {a : _} -> Var85 g a -> Var85 (snoc85 g B) a
vs85 = \ x, var, vz85, vs85 => vs85 _ _ _ (x var vz85 vs85)

Tm85 : Con85 -> Ty85 -> Type
Tm85 = \ g, a =>
    (Tm85    : Con85 -> Ty85 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var85 g a -> Tm85 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm85 (snoc85 g a) B -> Tm85 g (arr85 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm85 g (arr85 a B) -> Tm85 g a -> Tm85 g B)
 -> Tm85 g a

var85 : {g : _} -> {a : _} -> Var85 g a -> Tm85 g a
var85 = \ x, tm, var85, lam, app => var85 _ _ x

lam85 : {g : _} -> {a : _} -> {B : _} -> Tm85 (snoc85 g a) B -> Tm85 g (arr85 a B)
lam85 = \ t, tm, var85, lam85, app => lam85 _ _ _ (t tm var85 lam85 app)

app85 : {g:_}->{a:_}->{B:_} -> Tm85 g (arr85 a B) -> Tm85 g a -> Tm85 g B
app85 = \ t, u, tm, var85, lam85, app85 => app85 _ _ _ (t tm var85 lam85 app85) (u tm var85 lam85 app85)

v085 : {g:_}->{a:_} -> Tm85 (snoc85 g a) a
v085 = var85 vz85

v185 : {g:_}->{a:_}-> {B:_}-> Tm85 (snoc85 (snoc85 g a) B) a
v185 = var85 (vs85 vz85)

v285 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm85 (snoc85 (snoc85 (snoc85 g a) B) C) a
v285 = var85 (vs85 (vs85 vz85))

v385 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm85 (snoc85 (snoc85 (snoc85 (snoc85 g a) B) C) D) a
v385 = var85 (vs85 (vs85 (vs85 vz85)))

v485 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm85 (snoc85 (snoc85 (snoc85 (snoc85 (snoc85 g a) B) C) D) E) a
v485 = var85 (vs85 (vs85 (vs85 (vs85 vz85))))

test85 : {g:_}-> {a:_} -> Tm85 g (arr85 (arr85 a a) (arr85 a a))
test85  = lam85 (lam85 (app85 v185 (app85 v185 (app85 v185 (app85 v185 (app85 v185 (app85 v185 v085)))))))
Ty86 : Type
Ty86 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty86 : Ty86
empty86 = \ _, empty, _ => empty

arr86 : Ty86 -> Ty86 -> Ty86
arr86 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con86 : Type
Con86 = (Con86 : Type)
 ->(nil  : Con86)
 ->(snoc : Con86 -> Ty86 -> Con86)
 -> Con86

nil86 : Con86
nil86 = \ con, nil86, snoc => nil86

snoc86 : Con86 -> Ty86 -> Con86
snoc86 = \ g, a, con, nil86, snoc86 => snoc86 (g con nil86 snoc86) a

Var86 : Con86 -> Ty86 -> Type
Var86 = \ g, a =>
    (Var86 : Con86 -> Ty86 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var86 (snoc86 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var86 g a -> Var86 (snoc86 g b) a)
 -> Var86 g a

vz86 : {g : _}-> {a : _} -> Var86 (snoc86 g a) a
vz86 = \ var, vz86, vs => vz86 _ _

vs86 : {g : _} -> {B : _} -> {a : _} -> Var86 g a -> Var86 (snoc86 g B) a
vs86 = \ x, var, vz86, vs86 => vs86 _ _ _ (x var vz86 vs86)

Tm86 : Con86 -> Ty86 -> Type
Tm86 = \ g, a =>
    (Tm86    : Con86 -> Ty86 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var86 g a -> Tm86 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm86 (snoc86 g a) B -> Tm86 g (arr86 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm86 g (arr86 a B) -> Tm86 g a -> Tm86 g B)
 -> Tm86 g a

var86 : {g : _} -> {a : _} -> Var86 g a -> Tm86 g a
var86 = \ x, tm, var86, lam, app => var86 _ _ x

lam86 : {g : _} -> {a : _} -> {B : _} -> Tm86 (snoc86 g a) B -> Tm86 g (arr86 a B)
lam86 = \ t, tm, var86, lam86, app => lam86 _ _ _ (t tm var86 lam86 app)

app86 : {g:_}->{a:_}->{B:_} -> Tm86 g (arr86 a B) -> Tm86 g a -> Tm86 g B
app86 = \ t, u, tm, var86, lam86, app86 => app86 _ _ _ (t tm var86 lam86 app86) (u tm var86 lam86 app86)

v086 : {g:_}->{a:_} -> Tm86 (snoc86 g a) a
v086 = var86 vz86

v186 : {g:_}->{a:_}-> {B:_}-> Tm86 (snoc86 (snoc86 g a) B) a
v186 = var86 (vs86 vz86)

v286 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm86 (snoc86 (snoc86 (snoc86 g a) B) C) a
v286 = var86 (vs86 (vs86 vz86))

v386 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm86 (snoc86 (snoc86 (snoc86 (snoc86 g a) B) C) D) a
v386 = var86 (vs86 (vs86 (vs86 vz86)))

v486 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm86 (snoc86 (snoc86 (snoc86 (snoc86 (snoc86 g a) B) C) D) E) a
v486 = var86 (vs86 (vs86 (vs86 (vs86 vz86))))

test86 : {g:_}-> {a:_} -> Tm86 g (arr86 (arr86 a a) (arr86 a a))
test86  = lam86 (lam86 (app86 v186 (app86 v186 (app86 v186 (app86 v186 (app86 v186 (app86 v186 v086)))))))
Ty87 : Type
Ty87 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty87 : Ty87
empty87 = \ _, empty, _ => empty

arr87 : Ty87 -> Ty87 -> Ty87
arr87 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con87 : Type
Con87 = (Con87 : Type)
 ->(nil  : Con87)
 ->(snoc : Con87 -> Ty87 -> Con87)
 -> Con87

nil87 : Con87
nil87 = \ con, nil87, snoc => nil87

snoc87 : Con87 -> Ty87 -> Con87
snoc87 = \ g, a, con, nil87, snoc87 => snoc87 (g con nil87 snoc87) a

Var87 : Con87 -> Ty87 -> Type
Var87 = \ g, a =>
    (Var87 : Con87 -> Ty87 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var87 (snoc87 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var87 g a -> Var87 (snoc87 g b) a)
 -> Var87 g a

vz87 : {g : _}-> {a : _} -> Var87 (snoc87 g a) a
vz87 = \ var, vz87, vs => vz87 _ _

vs87 : {g : _} -> {B : _} -> {a : _} -> Var87 g a -> Var87 (snoc87 g B) a
vs87 = \ x, var, vz87, vs87 => vs87 _ _ _ (x var vz87 vs87)

Tm87 : Con87 -> Ty87 -> Type
Tm87 = \ g, a =>
    (Tm87    : Con87 -> Ty87 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var87 g a -> Tm87 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm87 (snoc87 g a) B -> Tm87 g (arr87 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm87 g (arr87 a B) -> Tm87 g a -> Tm87 g B)
 -> Tm87 g a

var87 : {g : _} -> {a : _} -> Var87 g a -> Tm87 g a
var87 = \ x, tm, var87, lam, app => var87 _ _ x

lam87 : {g : _} -> {a : _} -> {B : _} -> Tm87 (snoc87 g a) B -> Tm87 g (arr87 a B)
lam87 = \ t, tm, var87, lam87, app => lam87 _ _ _ (t tm var87 lam87 app)

app87 : {g:_}->{a:_}->{B:_} -> Tm87 g (arr87 a B) -> Tm87 g a -> Tm87 g B
app87 = \ t, u, tm, var87, lam87, app87 => app87 _ _ _ (t tm var87 lam87 app87) (u tm var87 lam87 app87)

v087 : {g:_}->{a:_} -> Tm87 (snoc87 g a) a
v087 = var87 vz87

v187 : {g:_}->{a:_}-> {B:_}-> Tm87 (snoc87 (snoc87 g a) B) a
v187 = var87 (vs87 vz87)

v287 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm87 (snoc87 (snoc87 (snoc87 g a) B) C) a
v287 = var87 (vs87 (vs87 vz87))

v387 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm87 (snoc87 (snoc87 (snoc87 (snoc87 g a) B) C) D) a
v387 = var87 (vs87 (vs87 (vs87 vz87)))

v487 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm87 (snoc87 (snoc87 (snoc87 (snoc87 (snoc87 g a) B) C) D) E) a
v487 = var87 (vs87 (vs87 (vs87 (vs87 vz87))))

test87 : {g:_}-> {a:_} -> Tm87 g (arr87 (arr87 a a) (arr87 a a))
test87  = lam87 (lam87 (app87 v187 (app87 v187 (app87 v187 (app87 v187 (app87 v187 (app87 v187 v087)))))))
Ty88 : Type
Ty88 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty88 : Ty88
empty88 = \ _, empty, _ => empty

arr88 : Ty88 -> Ty88 -> Ty88
arr88 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con88 : Type
Con88 = (Con88 : Type)
 ->(nil  : Con88)
 ->(snoc : Con88 -> Ty88 -> Con88)
 -> Con88

nil88 : Con88
nil88 = \ con, nil88, snoc => nil88

snoc88 : Con88 -> Ty88 -> Con88
snoc88 = \ g, a, con, nil88, snoc88 => snoc88 (g con nil88 snoc88) a

Var88 : Con88 -> Ty88 -> Type
Var88 = \ g, a =>
    (Var88 : Con88 -> Ty88 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var88 (snoc88 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var88 g a -> Var88 (snoc88 g b) a)
 -> Var88 g a

vz88 : {g : _}-> {a : _} -> Var88 (snoc88 g a) a
vz88 = \ var, vz88, vs => vz88 _ _

vs88 : {g : _} -> {B : _} -> {a : _} -> Var88 g a -> Var88 (snoc88 g B) a
vs88 = \ x, var, vz88, vs88 => vs88 _ _ _ (x var vz88 vs88)

Tm88 : Con88 -> Ty88 -> Type
Tm88 = \ g, a =>
    (Tm88    : Con88 -> Ty88 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var88 g a -> Tm88 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm88 (snoc88 g a) B -> Tm88 g (arr88 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm88 g (arr88 a B) -> Tm88 g a -> Tm88 g B)
 -> Tm88 g a

var88 : {g : _} -> {a : _} -> Var88 g a -> Tm88 g a
var88 = \ x, tm, var88, lam, app => var88 _ _ x

lam88 : {g : _} -> {a : _} -> {B : _} -> Tm88 (snoc88 g a) B -> Tm88 g (arr88 a B)
lam88 = \ t, tm, var88, lam88, app => lam88 _ _ _ (t tm var88 lam88 app)

app88 : {g:_}->{a:_}->{B:_} -> Tm88 g (arr88 a B) -> Tm88 g a -> Tm88 g B
app88 = \ t, u, tm, var88, lam88, app88 => app88 _ _ _ (t tm var88 lam88 app88) (u tm var88 lam88 app88)

v088 : {g:_}->{a:_} -> Tm88 (snoc88 g a) a
v088 = var88 vz88

v188 : {g:_}->{a:_}-> {B:_}-> Tm88 (snoc88 (snoc88 g a) B) a
v188 = var88 (vs88 vz88)

v288 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm88 (snoc88 (snoc88 (snoc88 g a) B) C) a
v288 = var88 (vs88 (vs88 vz88))

v388 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm88 (snoc88 (snoc88 (snoc88 (snoc88 g a) B) C) D) a
v388 = var88 (vs88 (vs88 (vs88 vz88)))

v488 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm88 (snoc88 (snoc88 (snoc88 (snoc88 (snoc88 g a) B) C) D) E) a
v488 = var88 (vs88 (vs88 (vs88 (vs88 vz88))))

test88 : {g:_}-> {a:_} -> Tm88 g (arr88 (arr88 a a) (arr88 a a))
test88  = lam88 (lam88 (app88 v188 (app88 v188 (app88 v188 (app88 v188 (app88 v188 (app88 v188 v088)))))))
Ty89 : Type
Ty89 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty89 : Ty89
empty89 = \ _, empty, _ => empty

arr89 : Ty89 -> Ty89 -> Ty89
arr89 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con89 : Type
Con89 = (Con89 : Type)
 ->(nil  : Con89)
 ->(snoc : Con89 -> Ty89 -> Con89)
 -> Con89

nil89 : Con89
nil89 = \ con, nil89, snoc => nil89

snoc89 : Con89 -> Ty89 -> Con89
snoc89 = \ g, a, con, nil89, snoc89 => snoc89 (g con nil89 snoc89) a

Var89 : Con89 -> Ty89 -> Type
Var89 = \ g, a =>
    (Var89 : Con89 -> Ty89 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var89 (snoc89 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var89 g a -> Var89 (snoc89 g b) a)
 -> Var89 g a

vz89 : {g : _}-> {a : _} -> Var89 (snoc89 g a) a
vz89 = \ var, vz89, vs => vz89 _ _

vs89 : {g : _} -> {B : _} -> {a : _} -> Var89 g a -> Var89 (snoc89 g B) a
vs89 = \ x, var, vz89, vs89 => vs89 _ _ _ (x var vz89 vs89)

Tm89 : Con89 -> Ty89 -> Type
Tm89 = \ g, a =>
    (Tm89    : Con89 -> Ty89 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var89 g a -> Tm89 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm89 (snoc89 g a) B -> Tm89 g (arr89 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm89 g (arr89 a B) -> Tm89 g a -> Tm89 g B)
 -> Tm89 g a

var89 : {g : _} -> {a : _} -> Var89 g a -> Tm89 g a
var89 = \ x, tm, var89, lam, app => var89 _ _ x

lam89 : {g : _} -> {a : _} -> {B : _} -> Tm89 (snoc89 g a) B -> Tm89 g (arr89 a B)
lam89 = \ t, tm, var89, lam89, app => lam89 _ _ _ (t tm var89 lam89 app)

app89 : {g:_}->{a:_}->{B:_} -> Tm89 g (arr89 a B) -> Tm89 g a -> Tm89 g B
app89 = \ t, u, tm, var89, lam89, app89 => app89 _ _ _ (t tm var89 lam89 app89) (u tm var89 lam89 app89)

v089 : {g:_}->{a:_} -> Tm89 (snoc89 g a) a
v089 = var89 vz89

v189 : {g:_}->{a:_}-> {B:_}-> Tm89 (snoc89 (snoc89 g a) B) a
v189 = var89 (vs89 vz89)

v289 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm89 (snoc89 (snoc89 (snoc89 g a) B) C) a
v289 = var89 (vs89 (vs89 vz89))

v389 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm89 (snoc89 (snoc89 (snoc89 (snoc89 g a) B) C) D) a
v389 = var89 (vs89 (vs89 (vs89 vz89)))

v489 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm89 (snoc89 (snoc89 (snoc89 (snoc89 (snoc89 g a) B) C) D) E) a
v489 = var89 (vs89 (vs89 (vs89 (vs89 vz89))))

test89 : {g:_}-> {a:_} -> Tm89 g (arr89 (arr89 a a) (arr89 a a))
test89  = lam89 (lam89 (app89 v189 (app89 v189 (app89 v189 (app89 v189 (app89 v189 (app89 v189 v089)))))))
Ty90 : Type
Ty90 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty90 : Ty90
empty90 = \ _, empty, _ => empty

arr90 : Ty90 -> Ty90 -> Ty90
arr90 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con90 : Type
Con90 = (Con90 : Type)
 ->(nil  : Con90)
 ->(snoc : Con90 -> Ty90 -> Con90)
 -> Con90

nil90 : Con90
nil90 = \ con, nil90, snoc => nil90

snoc90 : Con90 -> Ty90 -> Con90
snoc90 = \ g, a, con, nil90, snoc90 => snoc90 (g con nil90 snoc90) a

Var90 : Con90 -> Ty90 -> Type
Var90 = \ g, a =>
    (Var90 : Con90 -> Ty90 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var90 (snoc90 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var90 g a -> Var90 (snoc90 g b) a)
 -> Var90 g a

vz90 : {g : _}-> {a : _} -> Var90 (snoc90 g a) a
vz90 = \ var, vz90, vs => vz90 _ _

vs90 : {g : _} -> {B : _} -> {a : _} -> Var90 g a -> Var90 (snoc90 g B) a
vs90 = \ x, var, vz90, vs90 => vs90 _ _ _ (x var vz90 vs90)

Tm90 : Con90 -> Ty90 -> Type
Tm90 = \ g, a =>
    (Tm90    : Con90 -> Ty90 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var90 g a -> Tm90 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm90 (snoc90 g a) B -> Tm90 g (arr90 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm90 g (arr90 a B) -> Tm90 g a -> Tm90 g B)
 -> Tm90 g a

var90 : {g : _} -> {a : _} -> Var90 g a -> Tm90 g a
var90 = \ x, tm, var90, lam, app => var90 _ _ x

lam90 : {g : _} -> {a : _} -> {B : _} -> Tm90 (snoc90 g a) B -> Tm90 g (arr90 a B)
lam90 = \ t, tm, var90, lam90, app => lam90 _ _ _ (t tm var90 lam90 app)

app90 : {g:_}->{a:_}->{B:_} -> Tm90 g (arr90 a B) -> Tm90 g a -> Tm90 g B
app90 = \ t, u, tm, var90, lam90, app90 => app90 _ _ _ (t tm var90 lam90 app90) (u tm var90 lam90 app90)

v090 : {g:_}->{a:_} -> Tm90 (snoc90 g a) a
v090 = var90 vz90

v190 : {g:_}->{a:_}-> {B:_}-> Tm90 (snoc90 (snoc90 g a) B) a
v190 = var90 (vs90 vz90)

v290 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm90 (snoc90 (snoc90 (snoc90 g a) B) C) a
v290 = var90 (vs90 (vs90 vz90))

v390 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm90 (snoc90 (snoc90 (snoc90 (snoc90 g a) B) C) D) a
v390 = var90 (vs90 (vs90 (vs90 vz90)))

v490 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm90 (snoc90 (snoc90 (snoc90 (snoc90 (snoc90 g a) B) C) D) E) a
v490 = var90 (vs90 (vs90 (vs90 (vs90 vz90))))

test90 : {g:_}-> {a:_} -> Tm90 g (arr90 (arr90 a a) (arr90 a a))
test90  = lam90 (lam90 (app90 v190 (app90 v190 (app90 v190 (app90 v190 (app90 v190 (app90 v190 v090)))))))
Ty91 : Type
Ty91 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty91 : Ty91
empty91 = \ _, empty, _ => empty

arr91 : Ty91 -> Ty91 -> Ty91
arr91 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con91 : Type
Con91 = (Con91 : Type)
 ->(nil  : Con91)
 ->(snoc : Con91 -> Ty91 -> Con91)
 -> Con91

nil91 : Con91
nil91 = \ con, nil91, snoc => nil91

snoc91 : Con91 -> Ty91 -> Con91
snoc91 = \ g, a, con, nil91, snoc91 => snoc91 (g con nil91 snoc91) a

Var91 : Con91 -> Ty91 -> Type
Var91 = \ g, a =>
    (Var91 : Con91 -> Ty91 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var91 (snoc91 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var91 g a -> Var91 (snoc91 g b) a)
 -> Var91 g a

vz91 : {g : _}-> {a : _} -> Var91 (snoc91 g a) a
vz91 = \ var, vz91, vs => vz91 _ _

vs91 : {g : _} -> {B : _} -> {a : _} -> Var91 g a -> Var91 (snoc91 g B) a
vs91 = \ x, var, vz91, vs91 => vs91 _ _ _ (x var vz91 vs91)

Tm91 : Con91 -> Ty91 -> Type
Tm91 = \ g, a =>
    (Tm91    : Con91 -> Ty91 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var91 g a -> Tm91 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm91 (snoc91 g a) B -> Tm91 g (arr91 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm91 g (arr91 a B) -> Tm91 g a -> Tm91 g B)
 -> Tm91 g a

var91 : {g : _} -> {a : _} -> Var91 g a -> Tm91 g a
var91 = \ x, tm, var91, lam, app => var91 _ _ x

lam91 : {g : _} -> {a : _} -> {B : _} -> Tm91 (snoc91 g a) B -> Tm91 g (arr91 a B)
lam91 = \ t, tm, var91, lam91, app => lam91 _ _ _ (t tm var91 lam91 app)

app91 : {g:_}->{a:_}->{B:_} -> Tm91 g (arr91 a B) -> Tm91 g a -> Tm91 g B
app91 = \ t, u, tm, var91, lam91, app91 => app91 _ _ _ (t tm var91 lam91 app91) (u tm var91 lam91 app91)

v091 : {g:_}->{a:_} -> Tm91 (snoc91 g a) a
v091 = var91 vz91

v191 : {g:_}->{a:_}-> {B:_}-> Tm91 (snoc91 (snoc91 g a) B) a
v191 = var91 (vs91 vz91)

v291 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm91 (snoc91 (snoc91 (snoc91 g a) B) C) a
v291 = var91 (vs91 (vs91 vz91))

v391 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm91 (snoc91 (snoc91 (snoc91 (snoc91 g a) B) C) D) a
v391 = var91 (vs91 (vs91 (vs91 vz91)))

v491 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm91 (snoc91 (snoc91 (snoc91 (snoc91 (snoc91 g a) B) C) D) E) a
v491 = var91 (vs91 (vs91 (vs91 (vs91 vz91))))

test91 : {g:_}-> {a:_} -> Tm91 g (arr91 (arr91 a a) (arr91 a a))
test91  = lam91 (lam91 (app91 v191 (app91 v191 (app91 v191 (app91 v191 (app91 v191 (app91 v191 v091)))))))
Ty92 : Type
Ty92 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty92 : Ty92
empty92 = \ _, empty, _ => empty

arr92 : Ty92 -> Ty92 -> Ty92
arr92 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con92 : Type
Con92 = (Con92 : Type)
 ->(nil  : Con92)
 ->(snoc : Con92 -> Ty92 -> Con92)
 -> Con92

nil92 : Con92
nil92 = \ con, nil92, snoc => nil92

snoc92 : Con92 -> Ty92 -> Con92
snoc92 = \ g, a, con, nil92, snoc92 => snoc92 (g con nil92 snoc92) a

Var92 : Con92 -> Ty92 -> Type
Var92 = \ g, a =>
    (Var92 : Con92 -> Ty92 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var92 (snoc92 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var92 g a -> Var92 (snoc92 g b) a)
 -> Var92 g a

vz92 : {g : _}-> {a : _} -> Var92 (snoc92 g a) a
vz92 = \ var, vz92, vs => vz92 _ _

vs92 : {g : _} -> {B : _} -> {a : _} -> Var92 g a -> Var92 (snoc92 g B) a
vs92 = \ x, var, vz92, vs92 => vs92 _ _ _ (x var vz92 vs92)

Tm92 : Con92 -> Ty92 -> Type
Tm92 = \ g, a =>
    (Tm92    : Con92 -> Ty92 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var92 g a -> Tm92 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm92 (snoc92 g a) B -> Tm92 g (arr92 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm92 g (arr92 a B) -> Tm92 g a -> Tm92 g B)
 -> Tm92 g a

var92 : {g : _} -> {a : _} -> Var92 g a -> Tm92 g a
var92 = \ x, tm, var92, lam, app => var92 _ _ x

lam92 : {g : _} -> {a : _} -> {B : _} -> Tm92 (snoc92 g a) B -> Tm92 g (arr92 a B)
lam92 = \ t, tm, var92, lam92, app => lam92 _ _ _ (t tm var92 lam92 app)

app92 : {g:_}->{a:_}->{B:_} -> Tm92 g (arr92 a B) -> Tm92 g a -> Tm92 g B
app92 = \ t, u, tm, var92, lam92, app92 => app92 _ _ _ (t tm var92 lam92 app92) (u tm var92 lam92 app92)

v092 : {g:_}->{a:_} -> Tm92 (snoc92 g a) a
v092 = var92 vz92

v192 : {g:_}->{a:_}-> {B:_}-> Tm92 (snoc92 (snoc92 g a) B) a
v192 = var92 (vs92 vz92)

v292 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm92 (snoc92 (snoc92 (snoc92 g a) B) C) a
v292 = var92 (vs92 (vs92 vz92))

v392 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm92 (snoc92 (snoc92 (snoc92 (snoc92 g a) B) C) D) a
v392 = var92 (vs92 (vs92 (vs92 vz92)))

v492 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm92 (snoc92 (snoc92 (snoc92 (snoc92 (snoc92 g a) B) C) D) E) a
v492 = var92 (vs92 (vs92 (vs92 (vs92 vz92))))

test92 : {g:_}-> {a:_} -> Tm92 g (arr92 (arr92 a a) (arr92 a a))
test92  = lam92 (lam92 (app92 v192 (app92 v192 (app92 v192 (app92 v192 (app92 v192 (app92 v192 v092)))))))
Ty93 : Type
Ty93 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty93 : Ty93
empty93 = \ _, empty, _ => empty

arr93 : Ty93 -> Ty93 -> Ty93
arr93 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con93 : Type
Con93 = (Con93 : Type)
 ->(nil  : Con93)
 ->(snoc : Con93 -> Ty93 -> Con93)
 -> Con93

nil93 : Con93
nil93 = \ con, nil93, snoc => nil93

snoc93 : Con93 -> Ty93 -> Con93
snoc93 = \ g, a, con, nil93, snoc93 => snoc93 (g con nil93 snoc93) a

Var93 : Con93 -> Ty93 -> Type
Var93 = \ g, a =>
    (Var93 : Con93 -> Ty93 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var93 (snoc93 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var93 g a -> Var93 (snoc93 g b) a)
 -> Var93 g a

vz93 : {g : _}-> {a : _} -> Var93 (snoc93 g a) a
vz93 = \ var, vz93, vs => vz93 _ _

vs93 : {g : _} -> {B : _} -> {a : _} -> Var93 g a -> Var93 (snoc93 g B) a
vs93 = \ x, var, vz93, vs93 => vs93 _ _ _ (x var vz93 vs93)

Tm93 : Con93 -> Ty93 -> Type
Tm93 = \ g, a =>
    (Tm93    : Con93 -> Ty93 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var93 g a -> Tm93 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm93 (snoc93 g a) B -> Tm93 g (arr93 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm93 g (arr93 a B) -> Tm93 g a -> Tm93 g B)
 -> Tm93 g a

var93 : {g : _} -> {a : _} -> Var93 g a -> Tm93 g a
var93 = \ x, tm, var93, lam, app => var93 _ _ x

lam93 : {g : _} -> {a : _} -> {B : _} -> Tm93 (snoc93 g a) B -> Tm93 g (arr93 a B)
lam93 = \ t, tm, var93, lam93, app => lam93 _ _ _ (t tm var93 lam93 app)

app93 : {g:_}->{a:_}->{B:_} -> Tm93 g (arr93 a B) -> Tm93 g a -> Tm93 g B
app93 = \ t, u, tm, var93, lam93, app93 => app93 _ _ _ (t tm var93 lam93 app93) (u tm var93 lam93 app93)

v093 : {g:_}->{a:_} -> Tm93 (snoc93 g a) a
v093 = var93 vz93

v193 : {g:_}->{a:_}-> {B:_}-> Tm93 (snoc93 (snoc93 g a) B) a
v193 = var93 (vs93 vz93)

v293 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm93 (snoc93 (snoc93 (snoc93 g a) B) C) a
v293 = var93 (vs93 (vs93 vz93))

v393 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm93 (snoc93 (snoc93 (snoc93 (snoc93 g a) B) C) D) a
v393 = var93 (vs93 (vs93 (vs93 vz93)))

v493 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm93 (snoc93 (snoc93 (snoc93 (snoc93 (snoc93 g a) B) C) D) E) a
v493 = var93 (vs93 (vs93 (vs93 (vs93 vz93))))

test93 : {g:_}-> {a:_} -> Tm93 g (arr93 (arr93 a a) (arr93 a a))
test93  = lam93 (lam93 (app93 v193 (app93 v193 (app93 v193 (app93 v193 (app93 v193 (app93 v193 v093)))))))
Ty94 : Type
Ty94 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty94 : Ty94
empty94 = \ _, empty, _ => empty

arr94 : Ty94 -> Ty94 -> Ty94
arr94 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con94 : Type
Con94 = (Con94 : Type)
 ->(nil  : Con94)
 ->(snoc : Con94 -> Ty94 -> Con94)
 -> Con94

nil94 : Con94
nil94 = \ con, nil94, snoc => nil94

snoc94 : Con94 -> Ty94 -> Con94
snoc94 = \ g, a, con, nil94, snoc94 => snoc94 (g con nil94 snoc94) a

Var94 : Con94 -> Ty94 -> Type
Var94 = \ g, a =>
    (Var94 : Con94 -> Ty94 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var94 (snoc94 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var94 g a -> Var94 (snoc94 g b) a)
 -> Var94 g a

vz94 : {g : _}-> {a : _} -> Var94 (snoc94 g a) a
vz94 = \ var, vz94, vs => vz94 _ _

vs94 : {g : _} -> {B : _} -> {a : _} -> Var94 g a -> Var94 (snoc94 g B) a
vs94 = \ x, var, vz94, vs94 => vs94 _ _ _ (x var vz94 vs94)

Tm94 : Con94 -> Ty94 -> Type
Tm94 = \ g, a =>
    (Tm94    : Con94 -> Ty94 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var94 g a -> Tm94 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm94 (snoc94 g a) B -> Tm94 g (arr94 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm94 g (arr94 a B) -> Tm94 g a -> Tm94 g B)
 -> Tm94 g a

var94 : {g : _} -> {a : _} -> Var94 g a -> Tm94 g a
var94 = \ x, tm, var94, lam, app => var94 _ _ x

lam94 : {g : _} -> {a : _} -> {B : _} -> Tm94 (snoc94 g a) B -> Tm94 g (arr94 a B)
lam94 = \ t, tm, var94, lam94, app => lam94 _ _ _ (t tm var94 lam94 app)

app94 : {g:_}->{a:_}->{B:_} -> Tm94 g (arr94 a B) -> Tm94 g a -> Tm94 g B
app94 = \ t, u, tm, var94, lam94, app94 => app94 _ _ _ (t tm var94 lam94 app94) (u tm var94 lam94 app94)

v094 : {g:_}->{a:_} -> Tm94 (snoc94 g a) a
v094 = var94 vz94

v194 : {g:_}->{a:_}-> {B:_}-> Tm94 (snoc94 (snoc94 g a) B) a
v194 = var94 (vs94 vz94)

v294 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm94 (snoc94 (snoc94 (snoc94 g a) B) C) a
v294 = var94 (vs94 (vs94 vz94))

v394 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm94 (snoc94 (snoc94 (snoc94 (snoc94 g a) B) C) D) a
v394 = var94 (vs94 (vs94 (vs94 vz94)))

v494 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm94 (snoc94 (snoc94 (snoc94 (snoc94 (snoc94 g a) B) C) D) E) a
v494 = var94 (vs94 (vs94 (vs94 (vs94 vz94))))

test94 : {g:_}-> {a:_} -> Tm94 g (arr94 (arr94 a a) (arr94 a a))
test94  = lam94 (lam94 (app94 v194 (app94 v194 (app94 v194 (app94 v194 (app94 v194 (app94 v194 v094)))))))
Ty95 : Type
Ty95 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty95 : Ty95
empty95 = \ _, empty, _ => empty

arr95 : Ty95 -> Ty95 -> Ty95
arr95 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con95 : Type
Con95 = (Con95 : Type)
 ->(nil  : Con95)
 ->(snoc : Con95 -> Ty95 -> Con95)
 -> Con95

nil95 : Con95
nil95 = \ con, nil95, snoc => nil95

snoc95 : Con95 -> Ty95 -> Con95
snoc95 = \ g, a, con, nil95, snoc95 => snoc95 (g con nil95 snoc95) a

Var95 : Con95 -> Ty95 -> Type
Var95 = \ g, a =>
    (Var95 : Con95 -> Ty95 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var95 (snoc95 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var95 g a -> Var95 (snoc95 g b) a)
 -> Var95 g a

vz95 : {g : _}-> {a : _} -> Var95 (snoc95 g a) a
vz95 = \ var, vz95, vs => vz95 _ _

vs95 : {g : _} -> {B : _} -> {a : _} -> Var95 g a -> Var95 (snoc95 g B) a
vs95 = \ x, var, vz95, vs95 => vs95 _ _ _ (x var vz95 vs95)

Tm95 : Con95 -> Ty95 -> Type
Tm95 = \ g, a =>
    (Tm95    : Con95 -> Ty95 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var95 g a -> Tm95 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm95 (snoc95 g a) B -> Tm95 g (arr95 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm95 g (arr95 a B) -> Tm95 g a -> Tm95 g B)
 -> Tm95 g a

var95 : {g : _} -> {a : _} -> Var95 g a -> Tm95 g a
var95 = \ x, tm, var95, lam, app => var95 _ _ x

lam95 : {g : _} -> {a : _} -> {B : _} -> Tm95 (snoc95 g a) B -> Tm95 g (arr95 a B)
lam95 = \ t, tm, var95, lam95, app => lam95 _ _ _ (t tm var95 lam95 app)

app95 : {g:_}->{a:_}->{B:_} -> Tm95 g (arr95 a B) -> Tm95 g a -> Tm95 g B
app95 = \ t, u, tm, var95, lam95, app95 => app95 _ _ _ (t tm var95 lam95 app95) (u tm var95 lam95 app95)

v095 : {g:_}->{a:_} -> Tm95 (snoc95 g a) a
v095 = var95 vz95

v195 : {g:_}->{a:_}-> {B:_}-> Tm95 (snoc95 (snoc95 g a) B) a
v195 = var95 (vs95 vz95)

v295 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm95 (snoc95 (snoc95 (snoc95 g a) B) C) a
v295 = var95 (vs95 (vs95 vz95))

v395 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm95 (snoc95 (snoc95 (snoc95 (snoc95 g a) B) C) D) a
v395 = var95 (vs95 (vs95 (vs95 vz95)))

v495 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm95 (snoc95 (snoc95 (snoc95 (snoc95 (snoc95 g a) B) C) D) E) a
v495 = var95 (vs95 (vs95 (vs95 (vs95 vz95))))

test95 : {g:_}-> {a:_} -> Tm95 g (arr95 (arr95 a a) (arr95 a a))
test95  = lam95 (lam95 (app95 v195 (app95 v195 (app95 v195 (app95 v195 (app95 v195 (app95 v195 v095)))))))
Ty96 : Type
Ty96 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty96 : Ty96
empty96 = \ _, empty, _ => empty

arr96 : Ty96 -> Ty96 -> Ty96
arr96 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con96 : Type
Con96 = (Con96 : Type)
 ->(nil  : Con96)
 ->(snoc : Con96 -> Ty96 -> Con96)
 -> Con96

nil96 : Con96
nil96 = \ con, nil96, snoc => nil96

snoc96 : Con96 -> Ty96 -> Con96
snoc96 = \ g, a, con, nil96, snoc96 => snoc96 (g con nil96 snoc96) a

Var96 : Con96 -> Ty96 -> Type
Var96 = \ g, a =>
    (Var96 : Con96 -> Ty96 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var96 (snoc96 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var96 g a -> Var96 (snoc96 g b) a)
 -> Var96 g a

vz96 : {g : _}-> {a : _} -> Var96 (snoc96 g a) a
vz96 = \ var, vz96, vs => vz96 _ _

vs96 : {g : _} -> {B : _} -> {a : _} -> Var96 g a -> Var96 (snoc96 g B) a
vs96 = \ x, var, vz96, vs96 => vs96 _ _ _ (x var vz96 vs96)

Tm96 : Con96 -> Ty96 -> Type
Tm96 = \ g, a =>
    (Tm96    : Con96 -> Ty96 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var96 g a -> Tm96 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm96 (snoc96 g a) B -> Tm96 g (arr96 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm96 g (arr96 a B) -> Tm96 g a -> Tm96 g B)
 -> Tm96 g a

var96 : {g : _} -> {a : _} -> Var96 g a -> Tm96 g a
var96 = \ x, tm, var96, lam, app => var96 _ _ x

lam96 : {g : _} -> {a : _} -> {B : _} -> Tm96 (snoc96 g a) B -> Tm96 g (arr96 a B)
lam96 = \ t, tm, var96, lam96, app => lam96 _ _ _ (t tm var96 lam96 app)

app96 : {g:_}->{a:_}->{B:_} -> Tm96 g (arr96 a B) -> Tm96 g a -> Tm96 g B
app96 = \ t, u, tm, var96, lam96, app96 => app96 _ _ _ (t tm var96 lam96 app96) (u tm var96 lam96 app96)

v096 : {g:_}->{a:_} -> Tm96 (snoc96 g a) a
v096 = var96 vz96

v196 : {g:_}->{a:_}-> {B:_}-> Tm96 (snoc96 (snoc96 g a) B) a
v196 = var96 (vs96 vz96)

v296 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm96 (snoc96 (snoc96 (snoc96 g a) B) C) a
v296 = var96 (vs96 (vs96 vz96))

v396 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm96 (snoc96 (snoc96 (snoc96 (snoc96 g a) B) C) D) a
v396 = var96 (vs96 (vs96 (vs96 vz96)))

v496 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm96 (snoc96 (snoc96 (snoc96 (snoc96 (snoc96 g a) B) C) D) E) a
v496 = var96 (vs96 (vs96 (vs96 (vs96 vz96))))

test96 : {g:_}-> {a:_} -> Tm96 g (arr96 (arr96 a a) (arr96 a a))
test96  = lam96 (lam96 (app96 v196 (app96 v196 (app96 v196 (app96 v196 (app96 v196 (app96 v196 v096)))))))
Ty97 : Type
Ty97 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty97 : Ty97
empty97 = \ _, empty, _ => empty

arr97 : Ty97 -> Ty97 -> Ty97
arr97 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con97 : Type
Con97 = (Con97 : Type)
 ->(nil  : Con97)
 ->(snoc : Con97 -> Ty97 -> Con97)
 -> Con97

nil97 : Con97
nil97 = \ con, nil97, snoc => nil97

snoc97 : Con97 -> Ty97 -> Con97
snoc97 = \ g, a, con, nil97, snoc97 => snoc97 (g con nil97 snoc97) a

Var97 : Con97 -> Ty97 -> Type
Var97 = \ g, a =>
    (Var97 : Con97 -> Ty97 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var97 (snoc97 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var97 g a -> Var97 (snoc97 g b) a)
 -> Var97 g a

vz97 : {g : _}-> {a : _} -> Var97 (snoc97 g a) a
vz97 = \ var, vz97, vs => vz97 _ _

vs97 : {g : _} -> {B : _} -> {a : _} -> Var97 g a -> Var97 (snoc97 g B) a
vs97 = \ x, var, vz97, vs97 => vs97 _ _ _ (x var vz97 vs97)

Tm97 : Con97 -> Ty97 -> Type
Tm97 = \ g, a =>
    (Tm97    : Con97 -> Ty97 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var97 g a -> Tm97 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm97 (snoc97 g a) B -> Tm97 g (arr97 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm97 g (arr97 a B) -> Tm97 g a -> Tm97 g B)
 -> Tm97 g a

var97 : {g : _} -> {a : _} -> Var97 g a -> Tm97 g a
var97 = \ x, tm, var97, lam, app => var97 _ _ x

lam97 : {g : _} -> {a : _} -> {B : _} -> Tm97 (snoc97 g a) B -> Tm97 g (arr97 a B)
lam97 = \ t, tm, var97, lam97, app => lam97 _ _ _ (t tm var97 lam97 app)

app97 : {g:_}->{a:_}->{B:_} -> Tm97 g (arr97 a B) -> Tm97 g a -> Tm97 g B
app97 = \ t, u, tm, var97, lam97, app97 => app97 _ _ _ (t tm var97 lam97 app97) (u tm var97 lam97 app97)

v097 : {g:_}->{a:_} -> Tm97 (snoc97 g a) a
v097 = var97 vz97

v197 : {g:_}->{a:_}-> {B:_}-> Tm97 (snoc97 (snoc97 g a) B) a
v197 = var97 (vs97 vz97)

v297 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm97 (snoc97 (snoc97 (snoc97 g a) B) C) a
v297 = var97 (vs97 (vs97 vz97))

v397 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm97 (snoc97 (snoc97 (snoc97 (snoc97 g a) B) C) D) a
v397 = var97 (vs97 (vs97 (vs97 vz97)))

v497 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm97 (snoc97 (snoc97 (snoc97 (snoc97 (snoc97 g a) B) C) D) E) a
v497 = var97 (vs97 (vs97 (vs97 (vs97 vz97))))

test97 : {g:_}-> {a:_} -> Tm97 g (arr97 (arr97 a a) (arr97 a a))
test97  = lam97 (lam97 (app97 v197 (app97 v197 (app97 v197 (app97 v197 (app97 v197 (app97 v197 v097)))))))
Ty98 : Type
Ty98 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty98 : Ty98
empty98 = \ _, empty, _ => empty

arr98 : Ty98 -> Ty98 -> Ty98
arr98 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con98 : Type
Con98 = (Con98 : Type)
 ->(nil  : Con98)
 ->(snoc : Con98 -> Ty98 -> Con98)
 -> Con98

nil98 : Con98
nil98 = \ con, nil98, snoc => nil98

snoc98 : Con98 -> Ty98 -> Con98
snoc98 = \ g, a, con, nil98, snoc98 => snoc98 (g con nil98 snoc98) a

Var98 : Con98 -> Ty98 -> Type
Var98 = \ g, a =>
    (Var98 : Con98 -> Ty98 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var98 (snoc98 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var98 g a -> Var98 (snoc98 g b) a)
 -> Var98 g a

vz98 : {g : _}-> {a : _} -> Var98 (snoc98 g a) a
vz98 = \ var, vz98, vs => vz98 _ _

vs98 : {g : _} -> {B : _} -> {a : _} -> Var98 g a -> Var98 (snoc98 g B) a
vs98 = \ x, var, vz98, vs98 => vs98 _ _ _ (x var vz98 vs98)

Tm98 : Con98 -> Ty98 -> Type
Tm98 = \ g, a =>
    (Tm98    : Con98 -> Ty98 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var98 g a -> Tm98 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm98 (snoc98 g a) B -> Tm98 g (arr98 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm98 g (arr98 a B) -> Tm98 g a -> Tm98 g B)
 -> Tm98 g a

var98 : {g : _} -> {a : _} -> Var98 g a -> Tm98 g a
var98 = \ x, tm, var98, lam, app => var98 _ _ x

lam98 : {g : _} -> {a : _} -> {B : _} -> Tm98 (snoc98 g a) B -> Tm98 g (arr98 a B)
lam98 = \ t, tm, var98, lam98, app => lam98 _ _ _ (t tm var98 lam98 app)

app98 : {g:_}->{a:_}->{B:_} -> Tm98 g (arr98 a B) -> Tm98 g a -> Tm98 g B
app98 = \ t, u, tm, var98, lam98, app98 => app98 _ _ _ (t tm var98 lam98 app98) (u tm var98 lam98 app98)

v098 : {g:_}->{a:_} -> Tm98 (snoc98 g a) a
v098 = var98 vz98

v198 : {g:_}->{a:_}-> {B:_}-> Tm98 (snoc98 (snoc98 g a) B) a
v198 = var98 (vs98 vz98)

v298 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm98 (snoc98 (snoc98 (snoc98 g a) B) C) a
v298 = var98 (vs98 (vs98 vz98))

v398 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm98 (snoc98 (snoc98 (snoc98 (snoc98 g a) B) C) D) a
v398 = var98 (vs98 (vs98 (vs98 vz98)))

v498 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm98 (snoc98 (snoc98 (snoc98 (snoc98 (snoc98 g a) B) C) D) E) a
v498 = var98 (vs98 (vs98 (vs98 (vs98 vz98))))

test98 : {g:_}-> {a:_} -> Tm98 g (arr98 (arr98 a a) (arr98 a a))
test98  = lam98 (lam98 (app98 v198 (app98 v198 (app98 v198 (app98 v198 (app98 v198 (app98 v198 v098)))))))
Ty99 : Type
Ty99 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty99 : Ty99
empty99 = \ _, empty, _ => empty

arr99 : Ty99 -> Ty99 -> Ty99
arr99 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con99 : Type
Con99 = (Con99 : Type)
 ->(nil  : Con99)
 ->(snoc : Con99 -> Ty99 -> Con99)
 -> Con99

nil99 : Con99
nil99 = \ con, nil99, snoc => nil99

snoc99 : Con99 -> Ty99 -> Con99
snoc99 = \ g, a, con, nil99, snoc99 => snoc99 (g con nil99 snoc99) a

Var99 : Con99 -> Ty99 -> Type
Var99 = \ g, a =>
    (Var99 : Con99 -> Ty99 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var99 (snoc99 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var99 g a -> Var99 (snoc99 g b) a)
 -> Var99 g a

vz99 : {g : _}-> {a : _} -> Var99 (snoc99 g a) a
vz99 = \ var, vz99, vs => vz99 _ _

vs99 : {g : _} -> {B : _} -> {a : _} -> Var99 g a -> Var99 (snoc99 g B) a
vs99 = \ x, var, vz99, vs99 => vs99 _ _ _ (x var vz99 vs99)

Tm99 : Con99 -> Ty99 -> Type
Tm99 = \ g, a =>
    (Tm99    : Con99 -> Ty99 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var99 g a -> Tm99 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm99 (snoc99 g a) B -> Tm99 g (arr99 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm99 g (arr99 a B) -> Tm99 g a -> Tm99 g B)
 -> Tm99 g a

var99 : {g : _} -> {a : _} -> Var99 g a -> Tm99 g a
var99 = \ x, tm, var99, lam, app => var99 _ _ x

lam99 : {g : _} -> {a : _} -> {B : _} -> Tm99 (snoc99 g a) B -> Tm99 g (arr99 a B)
lam99 = \ t, tm, var99, lam99, app => lam99 _ _ _ (t tm var99 lam99 app)

app99 : {g:_}->{a:_}->{B:_} -> Tm99 g (arr99 a B) -> Tm99 g a -> Tm99 g B
app99 = \ t, u, tm, var99, lam99, app99 => app99 _ _ _ (t tm var99 lam99 app99) (u tm var99 lam99 app99)

v099 : {g:_}->{a:_} -> Tm99 (snoc99 g a) a
v099 = var99 vz99

v199 : {g:_}->{a:_}-> {B:_}-> Tm99 (snoc99 (snoc99 g a) B) a
v199 = var99 (vs99 vz99)

v299 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm99 (snoc99 (snoc99 (snoc99 g a) B) C) a
v299 = var99 (vs99 (vs99 vz99))

v399 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm99 (snoc99 (snoc99 (snoc99 (snoc99 g a) B) C) D) a
v399 = var99 (vs99 (vs99 (vs99 vz99)))

v499 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm99 (snoc99 (snoc99 (snoc99 (snoc99 (snoc99 g a) B) C) D) E) a
v499 = var99 (vs99 (vs99 (vs99 (vs99 vz99))))

test99 : {g:_}-> {a:_} -> Tm99 g (arr99 (arr99 a a) (arr99 a a))
test99  = lam99 (lam99 (app99 v199 (app99 v199 (app99 v199 (app99 v199 (app99 v199 (app99 v199 v099)))))))
Ty100 : Type
Ty100 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty100 : Ty100
empty100 = \ _, empty, _ => empty

arr100 : Ty100 -> Ty100 -> Ty100
arr100 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con100 : Type
Con100 = (Con100 : Type)
 ->(nil  : Con100)
 ->(snoc : Con100 -> Ty100 -> Con100)
 -> Con100

nil100 : Con100
nil100 = \ con, nil100, snoc => nil100

snoc100 : Con100 -> Ty100 -> Con100
snoc100 = \ g, a, con, nil100, snoc100 => snoc100 (g con nil100 snoc100) a

Var100 : Con100 -> Ty100 -> Type
Var100 = \ g, a =>
    (Var100 : Con100 -> Ty100 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var100 (snoc100 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var100 g a -> Var100 (snoc100 g b) a)
 -> Var100 g a

vz100 : {g : _}-> {a : _} -> Var100 (snoc100 g a) a
vz100 = \ var, vz100, vs => vz100 _ _

vs100 : {g : _} -> {B : _} -> {a : _} -> Var100 g a -> Var100 (snoc100 g B) a
vs100 = \ x, var, vz100, vs100 => vs100 _ _ _ (x var vz100 vs100)

Tm100 : Con100 -> Ty100 -> Type
Tm100 = \ g, a =>
    (Tm100    : Con100 -> Ty100 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var100 g a -> Tm100 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm100 (snoc100 g a) B -> Tm100 g (arr100 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm100 g (arr100 a B) -> Tm100 g a -> Tm100 g B)
 -> Tm100 g a

var100 : {g : _} -> {a : _} -> Var100 g a -> Tm100 g a
var100 = \ x, tm, var100, lam, app => var100 _ _ x

lam100 : {g : _} -> {a : _} -> {B : _} -> Tm100 (snoc100 g a) B -> Tm100 g (arr100 a B)
lam100 = \ t, tm, var100, lam100, app => lam100 _ _ _ (t tm var100 lam100 app)

app100 : {g:_}->{a:_}->{B:_} -> Tm100 g (arr100 a B) -> Tm100 g a -> Tm100 g B
app100 = \ t, u, tm, var100, lam100, app100 => app100 _ _ _ (t tm var100 lam100 app100) (u tm var100 lam100 app100)

v0100 : {g:_}->{a:_} -> Tm100 (snoc100 g a) a
v0100 = var100 vz100

v1100 : {g:_}->{a:_}-> {B:_}-> Tm100 (snoc100 (snoc100 g a) B) a
v1100 = var100 (vs100 vz100)

v2100 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm100 (snoc100 (snoc100 (snoc100 g a) B) C) a
v2100 = var100 (vs100 (vs100 vz100))

v3100 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm100 (snoc100 (snoc100 (snoc100 (snoc100 g a) B) C) D) a
v3100 = var100 (vs100 (vs100 (vs100 vz100)))

v4100 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm100 (snoc100 (snoc100 (snoc100 (snoc100 (snoc100 g a) B) C) D) E) a
v4100 = var100 (vs100 (vs100 (vs100 (vs100 vz100))))

test100 : {g:_}-> {a:_} -> Tm100 g (arr100 (arr100 a a) (arr100 a a))
test100  = lam100 (lam100 (app100 v1100 (app100 v1100 (app100 v1100 (app100 v1100 (app100 v1100 (app100 v1100 v0100)))))))
Ty101 : Type
Ty101 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty101 : Ty101
empty101 = \ _, empty, _ => empty

arr101 : Ty101 -> Ty101 -> Ty101
arr101 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con101 : Type
Con101 = (Con101 : Type)
 ->(nil  : Con101)
 ->(snoc : Con101 -> Ty101 -> Con101)
 -> Con101

nil101 : Con101
nil101 = \ con, nil101, snoc => nil101

snoc101 : Con101 -> Ty101 -> Con101
snoc101 = \ g, a, con, nil101, snoc101 => snoc101 (g con nil101 snoc101) a

Var101 : Con101 -> Ty101 -> Type
Var101 = \ g, a =>
    (Var101 : Con101 -> Ty101 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var101 (snoc101 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var101 g a -> Var101 (snoc101 g b) a)
 -> Var101 g a

vz101 : {g : _}-> {a : _} -> Var101 (snoc101 g a) a
vz101 = \ var, vz101, vs => vz101 _ _

vs101 : {g : _} -> {B : _} -> {a : _} -> Var101 g a -> Var101 (snoc101 g B) a
vs101 = \ x, var, vz101, vs101 => vs101 _ _ _ (x var vz101 vs101)

Tm101 : Con101 -> Ty101 -> Type
Tm101 = \ g, a =>
    (Tm101    : Con101 -> Ty101 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var101 g a -> Tm101 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm101 (snoc101 g a) B -> Tm101 g (arr101 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm101 g (arr101 a B) -> Tm101 g a -> Tm101 g B)
 -> Tm101 g a

var101 : {g : _} -> {a : _} -> Var101 g a -> Tm101 g a
var101 = \ x, tm, var101, lam, app => var101 _ _ x

lam101 : {g : _} -> {a : _} -> {B : _} -> Tm101 (snoc101 g a) B -> Tm101 g (arr101 a B)
lam101 = \ t, tm, var101, lam101, app => lam101 _ _ _ (t tm var101 lam101 app)

app101 : {g:_}->{a:_}->{B:_} -> Tm101 g (arr101 a B) -> Tm101 g a -> Tm101 g B
app101 = \ t, u, tm, var101, lam101, app101 => app101 _ _ _ (t tm var101 lam101 app101) (u tm var101 lam101 app101)

v0101 : {g:_}->{a:_} -> Tm101 (snoc101 g a) a
v0101 = var101 vz101

v1101 : {g:_}->{a:_}-> {B:_}-> Tm101 (snoc101 (snoc101 g a) B) a
v1101 = var101 (vs101 vz101)

v2101 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm101 (snoc101 (snoc101 (snoc101 g a) B) C) a
v2101 = var101 (vs101 (vs101 vz101))

v3101 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm101 (snoc101 (snoc101 (snoc101 (snoc101 g a) B) C) D) a
v3101 = var101 (vs101 (vs101 (vs101 vz101)))

v4101 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm101 (snoc101 (snoc101 (snoc101 (snoc101 (snoc101 g a) B) C) D) E) a
v4101 = var101 (vs101 (vs101 (vs101 (vs101 vz101))))

test101 : {g:_}-> {a:_} -> Tm101 g (arr101 (arr101 a a) (arr101 a a))
test101  = lam101 (lam101 (app101 v1101 (app101 v1101 (app101 v1101 (app101 v1101 (app101 v1101 (app101 v1101 v0101)))))))
Ty102 : Type
Ty102 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty102 : Ty102
empty102 = \ _, empty, _ => empty

arr102 : Ty102 -> Ty102 -> Ty102
arr102 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con102 : Type
Con102 = (Con102 : Type)
 ->(nil  : Con102)
 ->(snoc : Con102 -> Ty102 -> Con102)
 -> Con102

nil102 : Con102
nil102 = \ con, nil102, snoc => nil102

snoc102 : Con102 -> Ty102 -> Con102
snoc102 = \ g, a, con, nil102, snoc102 => snoc102 (g con nil102 snoc102) a

Var102 : Con102 -> Ty102 -> Type
Var102 = \ g, a =>
    (Var102 : Con102 -> Ty102 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var102 (snoc102 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var102 g a -> Var102 (snoc102 g b) a)
 -> Var102 g a

vz102 : {g : _}-> {a : _} -> Var102 (snoc102 g a) a
vz102 = \ var, vz102, vs => vz102 _ _

vs102 : {g : _} -> {B : _} -> {a : _} -> Var102 g a -> Var102 (snoc102 g B) a
vs102 = \ x, var, vz102, vs102 => vs102 _ _ _ (x var vz102 vs102)

Tm102 : Con102 -> Ty102 -> Type
Tm102 = \ g, a =>
    (Tm102    : Con102 -> Ty102 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var102 g a -> Tm102 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm102 (snoc102 g a) B -> Tm102 g (arr102 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm102 g (arr102 a B) -> Tm102 g a -> Tm102 g B)
 -> Tm102 g a

var102 : {g : _} -> {a : _} -> Var102 g a -> Tm102 g a
var102 = \ x, tm, var102, lam, app => var102 _ _ x

lam102 : {g : _} -> {a : _} -> {B : _} -> Tm102 (snoc102 g a) B -> Tm102 g (arr102 a B)
lam102 = \ t, tm, var102, lam102, app => lam102 _ _ _ (t tm var102 lam102 app)

app102 : {g:_}->{a:_}->{B:_} -> Tm102 g (arr102 a B) -> Tm102 g a -> Tm102 g B
app102 = \ t, u, tm, var102, lam102, app102 => app102 _ _ _ (t tm var102 lam102 app102) (u tm var102 lam102 app102)

v0102 : {g:_}->{a:_} -> Tm102 (snoc102 g a) a
v0102 = var102 vz102

v1102 : {g:_}->{a:_}-> {B:_}-> Tm102 (snoc102 (snoc102 g a) B) a
v1102 = var102 (vs102 vz102)

v2102 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm102 (snoc102 (snoc102 (snoc102 g a) B) C) a
v2102 = var102 (vs102 (vs102 vz102))

v3102 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm102 (snoc102 (snoc102 (snoc102 (snoc102 g a) B) C) D) a
v3102 = var102 (vs102 (vs102 (vs102 vz102)))

v4102 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm102 (snoc102 (snoc102 (snoc102 (snoc102 (snoc102 g a) B) C) D) E) a
v4102 = var102 (vs102 (vs102 (vs102 (vs102 vz102))))

test102 : {g:_}-> {a:_} -> Tm102 g (arr102 (arr102 a a) (arr102 a a))
test102  = lam102 (lam102 (app102 v1102 (app102 v1102 (app102 v1102 (app102 v1102 (app102 v1102 (app102 v1102 v0102)))))))
Ty103 : Type
Ty103 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty103 : Ty103
empty103 = \ _, empty, _ => empty

arr103 : Ty103 -> Ty103 -> Ty103
arr103 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con103 : Type
Con103 = (Con103 : Type)
 ->(nil  : Con103)
 ->(snoc : Con103 -> Ty103 -> Con103)
 -> Con103

nil103 : Con103
nil103 = \ con, nil103, snoc => nil103

snoc103 : Con103 -> Ty103 -> Con103
snoc103 = \ g, a, con, nil103, snoc103 => snoc103 (g con nil103 snoc103) a

Var103 : Con103 -> Ty103 -> Type
Var103 = \ g, a =>
    (Var103 : Con103 -> Ty103 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var103 (snoc103 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var103 g a -> Var103 (snoc103 g b) a)
 -> Var103 g a

vz103 : {g : _}-> {a : _} -> Var103 (snoc103 g a) a
vz103 = \ var, vz103, vs => vz103 _ _

vs103 : {g : _} -> {B : _} -> {a : _} -> Var103 g a -> Var103 (snoc103 g B) a
vs103 = \ x, var, vz103, vs103 => vs103 _ _ _ (x var vz103 vs103)

Tm103 : Con103 -> Ty103 -> Type
Tm103 = \ g, a =>
    (Tm103    : Con103 -> Ty103 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var103 g a -> Tm103 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm103 (snoc103 g a) B -> Tm103 g (arr103 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm103 g (arr103 a B) -> Tm103 g a -> Tm103 g B)
 -> Tm103 g a

var103 : {g : _} -> {a : _} -> Var103 g a -> Tm103 g a
var103 = \ x, tm, var103, lam, app => var103 _ _ x

lam103 : {g : _} -> {a : _} -> {B : _} -> Tm103 (snoc103 g a) B -> Tm103 g (arr103 a B)
lam103 = \ t, tm, var103, lam103, app => lam103 _ _ _ (t tm var103 lam103 app)

app103 : {g:_}->{a:_}->{B:_} -> Tm103 g (arr103 a B) -> Tm103 g a -> Tm103 g B
app103 = \ t, u, tm, var103, lam103, app103 => app103 _ _ _ (t tm var103 lam103 app103) (u tm var103 lam103 app103)

v0103 : {g:_}->{a:_} -> Tm103 (snoc103 g a) a
v0103 = var103 vz103

v1103 : {g:_}->{a:_}-> {B:_}-> Tm103 (snoc103 (snoc103 g a) B) a
v1103 = var103 (vs103 vz103)

v2103 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm103 (snoc103 (snoc103 (snoc103 g a) B) C) a
v2103 = var103 (vs103 (vs103 vz103))

v3103 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm103 (snoc103 (snoc103 (snoc103 (snoc103 g a) B) C) D) a
v3103 = var103 (vs103 (vs103 (vs103 vz103)))

v4103 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm103 (snoc103 (snoc103 (snoc103 (snoc103 (snoc103 g a) B) C) D) E) a
v4103 = var103 (vs103 (vs103 (vs103 (vs103 vz103))))

test103 : {g:_}-> {a:_} -> Tm103 g (arr103 (arr103 a a) (arr103 a a))
test103  = lam103 (lam103 (app103 v1103 (app103 v1103 (app103 v1103 (app103 v1103 (app103 v1103 (app103 v1103 v0103)))))))
Ty104 : Type
Ty104 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty104 : Ty104
empty104 = \ _, empty, _ => empty

arr104 : Ty104 -> Ty104 -> Ty104
arr104 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con104 : Type
Con104 = (Con104 : Type)
 ->(nil  : Con104)
 ->(snoc : Con104 -> Ty104 -> Con104)
 -> Con104

nil104 : Con104
nil104 = \ con, nil104, snoc => nil104

snoc104 : Con104 -> Ty104 -> Con104
snoc104 = \ g, a, con, nil104, snoc104 => snoc104 (g con nil104 snoc104) a

Var104 : Con104 -> Ty104 -> Type
Var104 = \ g, a =>
    (Var104 : Con104 -> Ty104 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var104 (snoc104 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var104 g a -> Var104 (snoc104 g b) a)
 -> Var104 g a

vz104 : {g : _}-> {a : _} -> Var104 (snoc104 g a) a
vz104 = \ var, vz104, vs => vz104 _ _

vs104 : {g : _} -> {B : _} -> {a : _} -> Var104 g a -> Var104 (snoc104 g B) a
vs104 = \ x, var, vz104, vs104 => vs104 _ _ _ (x var vz104 vs104)

Tm104 : Con104 -> Ty104 -> Type
Tm104 = \ g, a =>
    (Tm104    : Con104 -> Ty104 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var104 g a -> Tm104 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm104 (snoc104 g a) B -> Tm104 g (arr104 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm104 g (arr104 a B) -> Tm104 g a -> Tm104 g B)
 -> Tm104 g a

var104 : {g : _} -> {a : _} -> Var104 g a -> Tm104 g a
var104 = \ x, tm, var104, lam, app => var104 _ _ x

lam104 : {g : _} -> {a : _} -> {B : _} -> Tm104 (snoc104 g a) B -> Tm104 g (arr104 a B)
lam104 = \ t, tm, var104, lam104, app => lam104 _ _ _ (t tm var104 lam104 app)

app104 : {g:_}->{a:_}->{B:_} -> Tm104 g (arr104 a B) -> Tm104 g a -> Tm104 g B
app104 = \ t, u, tm, var104, lam104, app104 => app104 _ _ _ (t tm var104 lam104 app104) (u tm var104 lam104 app104)

v0104 : {g:_}->{a:_} -> Tm104 (snoc104 g a) a
v0104 = var104 vz104

v1104 : {g:_}->{a:_}-> {B:_}-> Tm104 (snoc104 (snoc104 g a) B) a
v1104 = var104 (vs104 vz104)

v2104 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm104 (snoc104 (snoc104 (snoc104 g a) B) C) a
v2104 = var104 (vs104 (vs104 vz104))

v3104 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm104 (snoc104 (snoc104 (snoc104 (snoc104 g a) B) C) D) a
v3104 = var104 (vs104 (vs104 (vs104 vz104)))

v4104 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm104 (snoc104 (snoc104 (snoc104 (snoc104 (snoc104 g a) B) C) D) E) a
v4104 = var104 (vs104 (vs104 (vs104 (vs104 vz104))))

test104 : {g:_}-> {a:_} -> Tm104 g (arr104 (arr104 a a) (arr104 a a))
test104  = lam104 (lam104 (app104 v1104 (app104 v1104 (app104 v1104 (app104 v1104 (app104 v1104 (app104 v1104 v0104)))))))
Ty105 : Type
Ty105 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty105 : Ty105
empty105 = \ _, empty, _ => empty

arr105 : Ty105 -> Ty105 -> Ty105
arr105 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con105 : Type
Con105 = (Con105 : Type)
 ->(nil  : Con105)
 ->(snoc : Con105 -> Ty105 -> Con105)
 -> Con105

nil105 : Con105
nil105 = \ con, nil105, snoc => nil105

snoc105 : Con105 -> Ty105 -> Con105
snoc105 = \ g, a, con, nil105, snoc105 => snoc105 (g con nil105 snoc105) a

Var105 : Con105 -> Ty105 -> Type
Var105 = \ g, a =>
    (Var105 : Con105 -> Ty105 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var105 (snoc105 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var105 g a -> Var105 (snoc105 g b) a)
 -> Var105 g a

vz105 : {g : _}-> {a : _} -> Var105 (snoc105 g a) a
vz105 = \ var, vz105, vs => vz105 _ _

vs105 : {g : _} -> {B : _} -> {a : _} -> Var105 g a -> Var105 (snoc105 g B) a
vs105 = \ x, var, vz105, vs105 => vs105 _ _ _ (x var vz105 vs105)

Tm105 : Con105 -> Ty105 -> Type
Tm105 = \ g, a =>
    (Tm105    : Con105 -> Ty105 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var105 g a -> Tm105 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm105 (snoc105 g a) B -> Tm105 g (arr105 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm105 g (arr105 a B) -> Tm105 g a -> Tm105 g B)
 -> Tm105 g a

var105 : {g : _} -> {a : _} -> Var105 g a -> Tm105 g a
var105 = \ x, tm, var105, lam, app => var105 _ _ x

lam105 : {g : _} -> {a : _} -> {B : _} -> Tm105 (snoc105 g a) B -> Tm105 g (arr105 a B)
lam105 = \ t, tm, var105, lam105, app => lam105 _ _ _ (t tm var105 lam105 app)

app105 : {g:_}->{a:_}->{B:_} -> Tm105 g (arr105 a B) -> Tm105 g a -> Tm105 g B
app105 = \ t, u, tm, var105, lam105, app105 => app105 _ _ _ (t tm var105 lam105 app105) (u tm var105 lam105 app105)

v0105 : {g:_}->{a:_} -> Tm105 (snoc105 g a) a
v0105 = var105 vz105

v1105 : {g:_}->{a:_}-> {B:_}-> Tm105 (snoc105 (snoc105 g a) B) a
v1105 = var105 (vs105 vz105)

v2105 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm105 (snoc105 (snoc105 (snoc105 g a) B) C) a
v2105 = var105 (vs105 (vs105 vz105))

v3105 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm105 (snoc105 (snoc105 (snoc105 (snoc105 g a) B) C) D) a
v3105 = var105 (vs105 (vs105 (vs105 vz105)))

v4105 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm105 (snoc105 (snoc105 (snoc105 (snoc105 (snoc105 g a) B) C) D) E) a
v4105 = var105 (vs105 (vs105 (vs105 (vs105 vz105))))

test105 : {g:_}-> {a:_} -> Tm105 g (arr105 (arr105 a a) (arr105 a a))
test105  = lam105 (lam105 (app105 v1105 (app105 v1105 (app105 v1105 (app105 v1105 (app105 v1105 (app105 v1105 v0105)))))))
Ty106 : Type
Ty106 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty106 : Ty106
empty106 = \ _, empty, _ => empty

arr106 : Ty106 -> Ty106 -> Ty106
arr106 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con106 : Type
Con106 = (Con106 : Type)
 ->(nil  : Con106)
 ->(snoc : Con106 -> Ty106 -> Con106)
 -> Con106

nil106 : Con106
nil106 = \ con, nil106, snoc => nil106

snoc106 : Con106 -> Ty106 -> Con106
snoc106 = \ g, a, con, nil106, snoc106 => snoc106 (g con nil106 snoc106) a

Var106 : Con106 -> Ty106 -> Type
Var106 = \ g, a =>
    (Var106 : Con106 -> Ty106 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var106 (snoc106 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var106 g a -> Var106 (snoc106 g b) a)
 -> Var106 g a

vz106 : {g : _}-> {a : _} -> Var106 (snoc106 g a) a
vz106 = \ var, vz106, vs => vz106 _ _

vs106 : {g : _} -> {B : _} -> {a : _} -> Var106 g a -> Var106 (snoc106 g B) a
vs106 = \ x, var, vz106, vs106 => vs106 _ _ _ (x var vz106 vs106)

Tm106 : Con106 -> Ty106 -> Type
Tm106 = \ g, a =>
    (Tm106    : Con106 -> Ty106 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var106 g a -> Tm106 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm106 (snoc106 g a) B -> Tm106 g (arr106 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm106 g (arr106 a B) -> Tm106 g a -> Tm106 g B)
 -> Tm106 g a

var106 : {g : _} -> {a : _} -> Var106 g a -> Tm106 g a
var106 = \ x, tm, var106, lam, app => var106 _ _ x

lam106 : {g : _} -> {a : _} -> {B : _} -> Tm106 (snoc106 g a) B -> Tm106 g (arr106 a B)
lam106 = \ t, tm, var106, lam106, app => lam106 _ _ _ (t tm var106 lam106 app)

app106 : {g:_}->{a:_}->{B:_} -> Tm106 g (arr106 a B) -> Tm106 g a -> Tm106 g B
app106 = \ t, u, tm, var106, lam106, app106 => app106 _ _ _ (t tm var106 lam106 app106) (u tm var106 lam106 app106)

v0106 : {g:_}->{a:_} -> Tm106 (snoc106 g a) a
v0106 = var106 vz106

v1106 : {g:_}->{a:_}-> {B:_}-> Tm106 (snoc106 (snoc106 g a) B) a
v1106 = var106 (vs106 vz106)

v2106 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm106 (snoc106 (snoc106 (snoc106 g a) B) C) a
v2106 = var106 (vs106 (vs106 vz106))

v3106 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm106 (snoc106 (snoc106 (snoc106 (snoc106 g a) B) C) D) a
v3106 = var106 (vs106 (vs106 (vs106 vz106)))

v4106 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm106 (snoc106 (snoc106 (snoc106 (snoc106 (snoc106 g a) B) C) D) E) a
v4106 = var106 (vs106 (vs106 (vs106 (vs106 vz106))))

test106 : {g:_}-> {a:_} -> Tm106 g (arr106 (arr106 a a) (arr106 a a))
test106  = lam106 (lam106 (app106 v1106 (app106 v1106 (app106 v1106 (app106 v1106 (app106 v1106 (app106 v1106 v0106)))))))
Ty107 : Type
Ty107 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty107 : Ty107
empty107 = \ _, empty, _ => empty

arr107 : Ty107 -> Ty107 -> Ty107
arr107 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con107 : Type
Con107 = (Con107 : Type)
 ->(nil  : Con107)
 ->(snoc : Con107 -> Ty107 -> Con107)
 -> Con107

nil107 : Con107
nil107 = \ con, nil107, snoc => nil107

snoc107 : Con107 -> Ty107 -> Con107
snoc107 = \ g, a, con, nil107, snoc107 => snoc107 (g con nil107 snoc107) a

Var107 : Con107 -> Ty107 -> Type
Var107 = \ g, a =>
    (Var107 : Con107 -> Ty107 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var107 (snoc107 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var107 g a -> Var107 (snoc107 g b) a)
 -> Var107 g a

vz107 : {g : _}-> {a : _} -> Var107 (snoc107 g a) a
vz107 = \ var, vz107, vs => vz107 _ _

vs107 : {g : _} -> {B : _} -> {a : _} -> Var107 g a -> Var107 (snoc107 g B) a
vs107 = \ x, var, vz107, vs107 => vs107 _ _ _ (x var vz107 vs107)

Tm107 : Con107 -> Ty107 -> Type
Tm107 = \ g, a =>
    (Tm107    : Con107 -> Ty107 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var107 g a -> Tm107 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm107 (snoc107 g a) B -> Tm107 g (arr107 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm107 g (arr107 a B) -> Tm107 g a -> Tm107 g B)
 -> Tm107 g a

var107 : {g : _} -> {a : _} -> Var107 g a -> Tm107 g a
var107 = \ x, tm, var107, lam, app => var107 _ _ x

lam107 : {g : _} -> {a : _} -> {B : _} -> Tm107 (snoc107 g a) B -> Tm107 g (arr107 a B)
lam107 = \ t, tm, var107, lam107, app => lam107 _ _ _ (t tm var107 lam107 app)

app107 : {g:_}->{a:_}->{B:_} -> Tm107 g (arr107 a B) -> Tm107 g a -> Tm107 g B
app107 = \ t, u, tm, var107, lam107, app107 => app107 _ _ _ (t tm var107 lam107 app107) (u tm var107 lam107 app107)

v0107 : {g:_}->{a:_} -> Tm107 (snoc107 g a) a
v0107 = var107 vz107

v1107 : {g:_}->{a:_}-> {B:_}-> Tm107 (snoc107 (snoc107 g a) B) a
v1107 = var107 (vs107 vz107)

v2107 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm107 (snoc107 (snoc107 (snoc107 g a) B) C) a
v2107 = var107 (vs107 (vs107 vz107))

v3107 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm107 (snoc107 (snoc107 (snoc107 (snoc107 g a) B) C) D) a
v3107 = var107 (vs107 (vs107 (vs107 vz107)))

v4107 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm107 (snoc107 (snoc107 (snoc107 (snoc107 (snoc107 g a) B) C) D) E) a
v4107 = var107 (vs107 (vs107 (vs107 (vs107 vz107))))

test107 : {g:_}-> {a:_} -> Tm107 g (arr107 (arr107 a a) (arr107 a a))
test107  = lam107 (lam107 (app107 v1107 (app107 v1107 (app107 v1107 (app107 v1107 (app107 v1107 (app107 v1107 v0107)))))))
Ty108 : Type
Ty108 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty108 : Ty108
empty108 = \ _, empty, _ => empty

arr108 : Ty108 -> Ty108 -> Ty108
arr108 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con108 : Type
Con108 = (Con108 : Type)
 ->(nil  : Con108)
 ->(snoc : Con108 -> Ty108 -> Con108)
 -> Con108

nil108 : Con108
nil108 = \ con, nil108, snoc => nil108

snoc108 : Con108 -> Ty108 -> Con108
snoc108 = \ g, a, con, nil108, snoc108 => snoc108 (g con nil108 snoc108) a

Var108 : Con108 -> Ty108 -> Type
Var108 = \ g, a =>
    (Var108 : Con108 -> Ty108 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var108 (snoc108 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var108 g a -> Var108 (snoc108 g b) a)
 -> Var108 g a

vz108 : {g : _}-> {a : _} -> Var108 (snoc108 g a) a
vz108 = \ var, vz108, vs => vz108 _ _

vs108 : {g : _} -> {B : _} -> {a : _} -> Var108 g a -> Var108 (snoc108 g B) a
vs108 = \ x, var, vz108, vs108 => vs108 _ _ _ (x var vz108 vs108)

Tm108 : Con108 -> Ty108 -> Type
Tm108 = \ g, a =>
    (Tm108    : Con108 -> Ty108 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var108 g a -> Tm108 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm108 (snoc108 g a) B -> Tm108 g (arr108 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm108 g (arr108 a B) -> Tm108 g a -> Tm108 g B)
 -> Tm108 g a

var108 : {g : _} -> {a : _} -> Var108 g a -> Tm108 g a
var108 = \ x, tm, var108, lam, app => var108 _ _ x

lam108 : {g : _} -> {a : _} -> {B : _} -> Tm108 (snoc108 g a) B -> Tm108 g (arr108 a B)
lam108 = \ t, tm, var108, lam108, app => lam108 _ _ _ (t tm var108 lam108 app)

app108 : {g:_}->{a:_}->{B:_} -> Tm108 g (arr108 a B) -> Tm108 g a -> Tm108 g B
app108 = \ t, u, tm, var108, lam108, app108 => app108 _ _ _ (t tm var108 lam108 app108) (u tm var108 lam108 app108)

v0108 : {g:_}->{a:_} -> Tm108 (snoc108 g a) a
v0108 = var108 vz108

v1108 : {g:_}->{a:_}-> {B:_}-> Tm108 (snoc108 (snoc108 g a) B) a
v1108 = var108 (vs108 vz108)

v2108 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm108 (snoc108 (snoc108 (snoc108 g a) B) C) a
v2108 = var108 (vs108 (vs108 vz108))

v3108 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm108 (snoc108 (snoc108 (snoc108 (snoc108 g a) B) C) D) a
v3108 = var108 (vs108 (vs108 (vs108 vz108)))

v4108 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm108 (snoc108 (snoc108 (snoc108 (snoc108 (snoc108 g a) B) C) D) E) a
v4108 = var108 (vs108 (vs108 (vs108 (vs108 vz108))))

test108 : {g:_}-> {a:_} -> Tm108 g (arr108 (arr108 a a) (arr108 a a))
test108  = lam108 (lam108 (app108 v1108 (app108 v1108 (app108 v1108 (app108 v1108 (app108 v1108 (app108 v1108 v0108)))))))
Ty109 : Type
Ty109 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty109 : Ty109
empty109 = \ _, empty, _ => empty

arr109 : Ty109 -> Ty109 -> Ty109
arr109 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con109 : Type
Con109 = (Con109 : Type)
 ->(nil  : Con109)
 ->(snoc : Con109 -> Ty109 -> Con109)
 -> Con109

nil109 : Con109
nil109 = \ con, nil109, snoc => nil109

snoc109 : Con109 -> Ty109 -> Con109
snoc109 = \ g, a, con, nil109, snoc109 => snoc109 (g con nil109 snoc109) a

Var109 : Con109 -> Ty109 -> Type
Var109 = \ g, a =>
    (Var109 : Con109 -> Ty109 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var109 (snoc109 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var109 g a -> Var109 (snoc109 g b) a)
 -> Var109 g a

vz109 : {g : _}-> {a : _} -> Var109 (snoc109 g a) a
vz109 = \ var, vz109, vs => vz109 _ _

vs109 : {g : _} -> {B : _} -> {a : _} -> Var109 g a -> Var109 (snoc109 g B) a
vs109 = \ x, var, vz109, vs109 => vs109 _ _ _ (x var vz109 vs109)

Tm109 : Con109 -> Ty109 -> Type
Tm109 = \ g, a =>
    (Tm109    : Con109 -> Ty109 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var109 g a -> Tm109 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm109 (snoc109 g a) B -> Tm109 g (arr109 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm109 g (arr109 a B) -> Tm109 g a -> Tm109 g B)
 -> Tm109 g a

var109 : {g : _} -> {a : _} -> Var109 g a -> Tm109 g a
var109 = \ x, tm, var109, lam, app => var109 _ _ x

lam109 : {g : _} -> {a : _} -> {B : _} -> Tm109 (snoc109 g a) B -> Tm109 g (arr109 a B)
lam109 = \ t, tm, var109, lam109, app => lam109 _ _ _ (t tm var109 lam109 app)

app109 : {g:_}->{a:_}->{B:_} -> Tm109 g (arr109 a B) -> Tm109 g a -> Tm109 g B
app109 = \ t, u, tm, var109, lam109, app109 => app109 _ _ _ (t tm var109 lam109 app109) (u tm var109 lam109 app109)

v0109 : {g:_}->{a:_} -> Tm109 (snoc109 g a) a
v0109 = var109 vz109

v1109 : {g:_}->{a:_}-> {B:_}-> Tm109 (snoc109 (snoc109 g a) B) a
v1109 = var109 (vs109 vz109)

v2109 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm109 (snoc109 (snoc109 (snoc109 g a) B) C) a
v2109 = var109 (vs109 (vs109 vz109))

v3109 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm109 (snoc109 (snoc109 (snoc109 (snoc109 g a) B) C) D) a
v3109 = var109 (vs109 (vs109 (vs109 vz109)))

v4109 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm109 (snoc109 (snoc109 (snoc109 (snoc109 (snoc109 g a) B) C) D) E) a
v4109 = var109 (vs109 (vs109 (vs109 (vs109 vz109))))

test109 : {g:_}-> {a:_} -> Tm109 g (arr109 (arr109 a a) (arr109 a a))
test109  = lam109 (lam109 (app109 v1109 (app109 v1109 (app109 v1109 (app109 v1109 (app109 v1109 (app109 v1109 v0109)))))))
Ty110 : Type
Ty110 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty110 : Ty110
empty110 = \ _, empty, _ => empty

arr110 : Ty110 -> Ty110 -> Ty110
arr110 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con110 : Type
Con110 = (Con110 : Type)
 ->(nil  : Con110)
 ->(snoc : Con110 -> Ty110 -> Con110)
 -> Con110

nil110 : Con110
nil110 = \ con, nil110, snoc => nil110

snoc110 : Con110 -> Ty110 -> Con110
snoc110 = \ g, a, con, nil110, snoc110 => snoc110 (g con nil110 snoc110) a

Var110 : Con110 -> Ty110 -> Type
Var110 = \ g, a =>
    (Var110 : Con110 -> Ty110 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var110 (snoc110 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var110 g a -> Var110 (snoc110 g b) a)
 -> Var110 g a

vz110 : {g : _}-> {a : _} -> Var110 (snoc110 g a) a
vz110 = \ var, vz110, vs => vz110 _ _

vs110 : {g : _} -> {B : _} -> {a : _} -> Var110 g a -> Var110 (snoc110 g B) a
vs110 = \ x, var, vz110, vs110 => vs110 _ _ _ (x var vz110 vs110)

Tm110 : Con110 -> Ty110 -> Type
Tm110 = \ g, a =>
    (Tm110    : Con110 -> Ty110 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var110 g a -> Tm110 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm110 (snoc110 g a) B -> Tm110 g (arr110 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm110 g (arr110 a B) -> Tm110 g a -> Tm110 g B)
 -> Tm110 g a

var110 : {g : _} -> {a : _} -> Var110 g a -> Tm110 g a
var110 = \ x, tm, var110, lam, app => var110 _ _ x

lam110 : {g : _} -> {a : _} -> {B : _} -> Tm110 (snoc110 g a) B -> Tm110 g (arr110 a B)
lam110 = \ t, tm, var110, lam110, app => lam110 _ _ _ (t tm var110 lam110 app)

app110 : {g:_}->{a:_}->{B:_} -> Tm110 g (arr110 a B) -> Tm110 g a -> Tm110 g B
app110 = \ t, u, tm, var110, lam110, app110 => app110 _ _ _ (t tm var110 lam110 app110) (u tm var110 lam110 app110)

v0110 : {g:_}->{a:_} -> Tm110 (snoc110 g a) a
v0110 = var110 vz110

v1110 : {g:_}->{a:_}-> {B:_}-> Tm110 (snoc110 (snoc110 g a) B) a
v1110 = var110 (vs110 vz110)

v2110 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm110 (snoc110 (snoc110 (snoc110 g a) B) C) a
v2110 = var110 (vs110 (vs110 vz110))

v3110 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm110 (snoc110 (snoc110 (snoc110 (snoc110 g a) B) C) D) a
v3110 = var110 (vs110 (vs110 (vs110 vz110)))

v4110 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm110 (snoc110 (snoc110 (snoc110 (snoc110 (snoc110 g a) B) C) D) E) a
v4110 = var110 (vs110 (vs110 (vs110 (vs110 vz110))))

test110 : {g:_}-> {a:_} -> Tm110 g (arr110 (arr110 a a) (arr110 a a))
test110  = lam110 (lam110 (app110 v1110 (app110 v1110 (app110 v1110 (app110 v1110 (app110 v1110 (app110 v1110 v0110)))))))
Ty111 : Type
Ty111 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty111 : Ty111
empty111 = \ _, empty, _ => empty

arr111 : Ty111 -> Ty111 -> Ty111
arr111 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con111 : Type
Con111 = (Con111 : Type)
 ->(nil  : Con111)
 ->(snoc : Con111 -> Ty111 -> Con111)
 -> Con111

nil111 : Con111
nil111 = \ con, nil111, snoc => nil111

snoc111 : Con111 -> Ty111 -> Con111
snoc111 = \ g, a, con, nil111, snoc111 => snoc111 (g con nil111 snoc111) a

Var111 : Con111 -> Ty111 -> Type
Var111 = \ g, a =>
    (Var111 : Con111 -> Ty111 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var111 (snoc111 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var111 g a -> Var111 (snoc111 g b) a)
 -> Var111 g a

vz111 : {g : _}-> {a : _} -> Var111 (snoc111 g a) a
vz111 = \ var, vz111, vs => vz111 _ _

vs111 : {g : _} -> {B : _} -> {a : _} -> Var111 g a -> Var111 (snoc111 g B) a
vs111 = \ x, var, vz111, vs111 => vs111 _ _ _ (x var vz111 vs111)

Tm111 : Con111 -> Ty111 -> Type
Tm111 = \ g, a =>
    (Tm111    : Con111 -> Ty111 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var111 g a -> Tm111 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm111 (snoc111 g a) B -> Tm111 g (arr111 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm111 g (arr111 a B) -> Tm111 g a -> Tm111 g B)
 -> Tm111 g a

var111 : {g : _} -> {a : _} -> Var111 g a -> Tm111 g a
var111 = \ x, tm, var111, lam, app => var111 _ _ x

lam111 : {g : _} -> {a : _} -> {B : _} -> Tm111 (snoc111 g a) B -> Tm111 g (arr111 a B)
lam111 = \ t, tm, var111, lam111, app => lam111 _ _ _ (t tm var111 lam111 app)

app111 : {g:_}->{a:_}->{B:_} -> Tm111 g (arr111 a B) -> Tm111 g a -> Tm111 g B
app111 = \ t, u, tm, var111, lam111, app111 => app111 _ _ _ (t tm var111 lam111 app111) (u tm var111 lam111 app111)

v0111 : {g:_}->{a:_} -> Tm111 (snoc111 g a) a
v0111 = var111 vz111

v1111 : {g:_}->{a:_}-> {B:_}-> Tm111 (snoc111 (snoc111 g a) B) a
v1111 = var111 (vs111 vz111)

v2111 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm111 (snoc111 (snoc111 (snoc111 g a) B) C) a
v2111 = var111 (vs111 (vs111 vz111))

v3111 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm111 (snoc111 (snoc111 (snoc111 (snoc111 g a) B) C) D) a
v3111 = var111 (vs111 (vs111 (vs111 vz111)))

v4111 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm111 (snoc111 (snoc111 (snoc111 (snoc111 (snoc111 g a) B) C) D) E) a
v4111 = var111 (vs111 (vs111 (vs111 (vs111 vz111))))

test111 : {g:_}-> {a:_} -> Tm111 g (arr111 (arr111 a a) (arr111 a a))
test111  = lam111 (lam111 (app111 v1111 (app111 v1111 (app111 v1111 (app111 v1111 (app111 v1111 (app111 v1111 v0111)))))))
Ty112 : Type
Ty112 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty112 : Ty112
empty112 = \ _, empty, _ => empty

arr112 : Ty112 -> Ty112 -> Ty112
arr112 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con112 : Type
Con112 = (Con112 : Type)
 ->(nil  : Con112)
 ->(snoc : Con112 -> Ty112 -> Con112)
 -> Con112

nil112 : Con112
nil112 = \ con, nil112, snoc => nil112

snoc112 : Con112 -> Ty112 -> Con112
snoc112 = \ g, a, con, nil112, snoc112 => snoc112 (g con nil112 snoc112) a

Var112 : Con112 -> Ty112 -> Type
Var112 = \ g, a =>
    (Var112 : Con112 -> Ty112 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var112 (snoc112 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var112 g a -> Var112 (snoc112 g b) a)
 -> Var112 g a

vz112 : {g : _}-> {a : _} -> Var112 (snoc112 g a) a
vz112 = \ var, vz112, vs => vz112 _ _

vs112 : {g : _} -> {B : _} -> {a : _} -> Var112 g a -> Var112 (snoc112 g B) a
vs112 = \ x, var, vz112, vs112 => vs112 _ _ _ (x var vz112 vs112)

Tm112 : Con112 -> Ty112 -> Type
Tm112 = \ g, a =>
    (Tm112    : Con112 -> Ty112 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var112 g a -> Tm112 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm112 (snoc112 g a) B -> Tm112 g (arr112 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm112 g (arr112 a B) -> Tm112 g a -> Tm112 g B)
 -> Tm112 g a

var112 : {g : _} -> {a : _} -> Var112 g a -> Tm112 g a
var112 = \ x, tm, var112, lam, app => var112 _ _ x

lam112 : {g : _} -> {a : _} -> {B : _} -> Tm112 (snoc112 g a) B -> Tm112 g (arr112 a B)
lam112 = \ t, tm, var112, lam112, app => lam112 _ _ _ (t tm var112 lam112 app)

app112 : {g:_}->{a:_}->{B:_} -> Tm112 g (arr112 a B) -> Tm112 g a -> Tm112 g B
app112 = \ t, u, tm, var112, lam112, app112 => app112 _ _ _ (t tm var112 lam112 app112) (u tm var112 lam112 app112)

v0112 : {g:_}->{a:_} -> Tm112 (snoc112 g a) a
v0112 = var112 vz112

v1112 : {g:_}->{a:_}-> {B:_}-> Tm112 (snoc112 (snoc112 g a) B) a
v1112 = var112 (vs112 vz112)

v2112 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm112 (snoc112 (snoc112 (snoc112 g a) B) C) a
v2112 = var112 (vs112 (vs112 vz112))

v3112 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm112 (snoc112 (snoc112 (snoc112 (snoc112 g a) B) C) D) a
v3112 = var112 (vs112 (vs112 (vs112 vz112)))

v4112 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm112 (snoc112 (snoc112 (snoc112 (snoc112 (snoc112 g a) B) C) D) E) a
v4112 = var112 (vs112 (vs112 (vs112 (vs112 vz112))))

test112 : {g:_}-> {a:_} -> Tm112 g (arr112 (arr112 a a) (arr112 a a))
test112  = lam112 (lam112 (app112 v1112 (app112 v1112 (app112 v1112 (app112 v1112 (app112 v1112 (app112 v1112 v0112)))))))
Ty113 : Type
Ty113 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty113 : Ty113
empty113 = \ _, empty, _ => empty

arr113 : Ty113 -> Ty113 -> Ty113
arr113 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con113 : Type
Con113 = (Con113 : Type)
 ->(nil  : Con113)
 ->(snoc : Con113 -> Ty113 -> Con113)
 -> Con113

nil113 : Con113
nil113 = \ con, nil113, snoc => nil113

snoc113 : Con113 -> Ty113 -> Con113
snoc113 = \ g, a, con, nil113, snoc113 => snoc113 (g con nil113 snoc113) a

Var113 : Con113 -> Ty113 -> Type
Var113 = \ g, a =>
    (Var113 : Con113 -> Ty113 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var113 (snoc113 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var113 g a -> Var113 (snoc113 g b) a)
 -> Var113 g a

vz113 : {g : _}-> {a : _} -> Var113 (snoc113 g a) a
vz113 = \ var, vz113, vs => vz113 _ _

vs113 : {g : _} -> {B : _} -> {a : _} -> Var113 g a -> Var113 (snoc113 g B) a
vs113 = \ x, var, vz113, vs113 => vs113 _ _ _ (x var vz113 vs113)

Tm113 : Con113 -> Ty113 -> Type
Tm113 = \ g, a =>
    (Tm113    : Con113 -> Ty113 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var113 g a -> Tm113 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm113 (snoc113 g a) B -> Tm113 g (arr113 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm113 g (arr113 a B) -> Tm113 g a -> Tm113 g B)
 -> Tm113 g a

var113 : {g : _} -> {a : _} -> Var113 g a -> Tm113 g a
var113 = \ x, tm, var113, lam, app => var113 _ _ x

lam113 : {g : _} -> {a : _} -> {B : _} -> Tm113 (snoc113 g a) B -> Tm113 g (arr113 a B)
lam113 = \ t, tm, var113, lam113, app => lam113 _ _ _ (t tm var113 lam113 app)

app113 : {g:_}->{a:_}->{B:_} -> Tm113 g (arr113 a B) -> Tm113 g a -> Tm113 g B
app113 = \ t, u, tm, var113, lam113, app113 => app113 _ _ _ (t tm var113 lam113 app113) (u tm var113 lam113 app113)

v0113 : {g:_}->{a:_} -> Tm113 (snoc113 g a) a
v0113 = var113 vz113

v1113 : {g:_}->{a:_}-> {B:_}-> Tm113 (snoc113 (snoc113 g a) B) a
v1113 = var113 (vs113 vz113)

v2113 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm113 (snoc113 (snoc113 (snoc113 g a) B) C) a
v2113 = var113 (vs113 (vs113 vz113))

v3113 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm113 (snoc113 (snoc113 (snoc113 (snoc113 g a) B) C) D) a
v3113 = var113 (vs113 (vs113 (vs113 vz113)))

v4113 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm113 (snoc113 (snoc113 (snoc113 (snoc113 (snoc113 g a) B) C) D) E) a
v4113 = var113 (vs113 (vs113 (vs113 (vs113 vz113))))

test113 : {g:_}-> {a:_} -> Tm113 g (arr113 (arr113 a a) (arr113 a a))
test113  = lam113 (lam113 (app113 v1113 (app113 v1113 (app113 v1113 (app113 v1113 (app113 v1113 (app113 v1113 v0113)))))))
Ty114 : Type
Ty114 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty114 : Ty114
empty114 = \ _, empty, _ => empty

arr114 : Ty114 -> Ty114 -> Ty114
arr114 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con114 : Type
Con114 = (Con114 : Type)
 ->(nil  : Con114)
 ->(snoc : Con114 -> Ty114 -> Con114)
 -> Con114

nil114 : Con114
nil114 = \ con, nil114, snoc => nil114

snoc114 : Con114 -> Ty114 -> Con114
snoc114 = \ g, a, con, nil114, snoc114 => snoc114 (g con nil114 snoc114) a

Var114 : Con114 -> Ty114 -> Type
Var114 = \ g, a =>
    (Var114 : Con114 -> Ty114 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var114 (snoc114 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var114 g a -> Var114 (snoc114 g b) a)
 -> Var114 g a

vz114 : {g : _}-> {a : _} -> Var114 (snoc114 g a) a
vz114 = \ var, vz114, vs => vz114 _ _

vs114 : {g : _} -> {B : _} -> {a : _} -> Var114 g a -> Var114 (snoc114 g B) a
vs114 = \ x, var, vz114, vs114 => vs114 _ _ _ (x var vz114 vs114)

Tm114 : Con114 -> Ty114 -> Type
Tm114 = \ g, a =>
    (Tm114    : Con114 -> Ty114 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var114 g a -> Tm114 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm114 (snoc114 g a) B -> Tm114 g (arr114 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm114 g (arr114 a B) -> Tm114 g a -> Tm114 g B)
 -> Tm114 g a

var114 : {g : _} -> {a : _} -> Var114 g a -> Tm114 g a
var114 = \ x, tm, var114, lam, app => var114 _ _ x

lam114 : {g : _} -> {a : _} -> {B : _} -> Tm114 (snoc114 g a) B -> Tm114 g (arr114 a B)
lam114 = \ t, tm, var114, lam114, app => lam114 _ _ _ (t tm var114 lam114 app)

app114 : {g:_}->{a:_}->{B:_} -> Tm114 g (arr114 a B) -> Tm114 g a -> Tm114 g B
app114 = \ t, u, tm, var114, lam114, app114 => app114 _ _ _ (t tm var114 lam114 app114) (u tm var114 lam114 app114)

v0114 : {g:_}->{a:_} -> Tm114 (snoc114 g a) a
v0114 = var114 vz114

v1114 : {g:_}->{a:_}-> {B:_}-> Tm114 (snoc114 (snoc114 g a) B) a
v1114 = var114 (vs114 vz114)

v2114 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm114 (snoc114 (snoc114 (snoc114 g a) B) C) a
v2114 = var114 (vs114 (vs114 vz114))

v3114 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm114 (snoc114 (snoc114 (snoc114 (snoc114 g a) B) C) D) a
v3114 = var114 (vs114 (vs114 (vs114 vz114)))

v4114 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm114 (snoc114 (snoc114 (snoc114 (snoc114 (snoc114 g a) B) C) D) E) a
v4114 = var114 (vs114 (vs114 (vs114 (vs114 vz114))))

test114 : {g:_}-> {a:_} -> Tm114 g (arr114 (arr114 a a) (arr114 a a))
test114  = lam114 (lam114 (app114 v1114 (app114 v1114 (app114 v1114 (app114 v1114 (app114 v1114 (app114 v1114 v0114)))))))
Ty115 : Type
Ty115 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty115 : Ty115
empty115 = \ _, empty, _ => empty

arr115 : Ty115 -> Ty115 -> Ty115
arr115 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con115 : Type
Con115 = (Con115 : Type)
 ->(nil  : Con115)
 ->(snoc : Con115 -> Ty115 -> Con115)
 -> Con115

nil115 : Con115
nil115 = \ con, nil115, snoc => nil115

snoc115 : Con115 -> Ty115 -> Con115
snoc115 = \ g, a, con, nil115, snoc115 => snoc115 (g con nil115 snoc115) a

Var115 : Con115 -> Ty115 -> Type
Var115 = \ g, a =>
    (Var115 : Con115 -> Ty115 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var115 (snoc115 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var115 g a -> Var115 (snoc115 g b) a)
 -> Var115 g a

vz115 : {g : _}-> {a : _} -> Var115 (snoc115 g a) a
vz115 = \ var, vz115, vs => vz115 _ _

vs115 : {g : _} -> {B : _} -> {a : _} -> Var115 g a -> Var115 (snoc115 g B) a
vs115 = \ x, var, vz115, vs115 => vs115 _ _ _ (x var vz115 vs115)

Tm115 : Con115 -> Ty115 -> Type
Tm115 = \ g, a =>
    (Tm115    : Con115 -> Ty115 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var115 g a -> Tm115 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm115 (snoc115 g a) B -> Tm115 g (arr115 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm115 g (arr115 a B) -> Tm115 g a -> Tm115 g B)
 -> Tm115 g a

var115 : {g : _} -> {a : _} -> Var115 g a -> Tm115 g a
var115 = \ x, tm, var115, lam, app => var115 _ _ x

lam115 : {g : _} -> {a : _} -> {B : _} -> Tm115 (snoc115 g a) B -> Tm115 g (arr115 a B)
lam115 = \ t, tm, var115, lam115, app => lam115 _ _ _ (t tm var115 lam115 app)

app115 : {g:_}->{a:_}->{B:_} -> Tm115 g (arr115 a B) -> Tm115 g a -> Tm115 g B
app115 = \ t, u, tm, var115, lam115, app115 => app115 _ _ _ (t tm var115 lam115 app115) (u tm var115 lam115 app115)

v0115 : {g:_}->{a:_} -> Tm115 (snoc115 g a) a
v0115 = var115 vz115

v1115 : {g:_}->{a:_}-> {B:_}-> Tm115 (snoc115 (snoc115 g a) B) a
v1115 = var115 (vs115 vz115)

v2115 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm115 (snoc115 (snoc115 (snoc115 g a) B) C) a
v2115 = var115 (vs115 (vs115 vz115))

v3115 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm115 (snoc115 (snoc115 (snoc115 (snoc115 g a) B) C) D) a
v3115 = var115 (vs115 (vs115 (vs115 vz115)))

v4115 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm115 (snoc115 (snoc115 (snoc115 (snoc115 (snoc115 g a) B) C) D) E) a
v4115 = var115 (vs115 (vs115 (vs115 (vs115 vz115))))

test115 : {g:_}-> {a:_} -> Tm115 g (arr115 (arr115 a a) (arr115 a a))
test115  = lam115 (lam115 (app115 v1115 (app115 v1115 (app115 v1115 (app115 v1115 (app115 v1115 (app115 v1115 v0115)))))))
Ty116 : Type
Ty116 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty116 : Ty116
empty116 = \ _, empty, _ => empty

arr116 : Ty116 -> Ty116 -> Ty116
arr116 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con116 : Type
Con116 = (Con116 : Type)
 ->(nil  : Con116)
 ->(snoc : Con116 -> Ty116 -> Con116)
 -> Con116

nil116 : Con116
nil116 = \ con, nil116, snoc => nil116

snoc116 : Con116 -> Ty116 -> Con116
snoc116 = \ g, a, con, nil116, snoc116 => snoc116 (g con nil116 snoc116) a

Var116 : Con116 -> Ty116 -> Type
Var116 = \ g, a =>
    (Var116 : Con116 -> Ty116 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var116 (snoc116 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var116 g a -> Var116 (snoc116 g b) a)
 -> Var116 g a

vz116 : {g : _}-> {a : _} -> Var116 (snoc116 g a) a
vz116 = \ var, vz116, vs => vz116 _ _

vs116 : {g : _} -> {B : _} -> {a : _} -> Var116 g a -> Var116 (snoc116 g B) a
vs116 = \ x, var, vz116, vs116 => vs116 _ _ _ (x var vz116 vs116)

Tm116 : Con116 -> Ty116 -> Type
Tm116 = \ g, a =>
    (Tm116    : Con116 -> Ty116 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var116 g a -> Tm116 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm116 (snoc116 g a) B -> Tm116 g (arr116 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm116 g (arr116 a B) -> Tm116 g a -> Tm116 g B)
 -> Tm116 g a

var116 : {g : _} -> {a : _} -> Var116 g a -> Tm116 g a
var116 = \ x, tm, var116, lam, app => var116 _ _ x

lam116 : {g : _} -> {a : _} -> {B : _} -> Tm116 (snoc116 g a) B -> Tm116 g (arr116 a B)
lam116 = \ t, tm, var116, lam116, app => lam116 _ _ _ (t tm var116 lam116 app)

app116 : {g:_}->{a:_}->{B:_} -> Tm116 g (arr116 a B) -> Tm116 g a -> Tm116 g B
app116 = \ t, u, tm, var116, lam116, app116 => app116 _ _ _ (t tm var116 lam116 app116) (u tm var116 lam116 app116)

v0116 : {g:_}->{a:_} -> Tm116 (snoc116 g a) a
v0116 = var116 vz116

v1116 : {g:_}->{a:_}-> {B:_}-> Tm116 (snoc116 (snoc116 g a) B) a
v1116 = var116 (vs116 vz116)

v2116 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm116 (snoc116 (snoc116 (snoc116 g a) B) C) a
v2116 = var116 (vs116 (vs116 vz116))

v3116 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm116 (snoc116 (snoc116 (snoc116 (snoc116 g a) B) C) D) a
v3116 = var116 (vs116 (vs116 (vs116 vz116)))

v4116 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm116 (snoc116 (snoc116 (snoc116 (snoc116 (snoc116 g a) B) C) D) E) a
v4116 = var116 (vs116 (vs116 (vs116 (vs116 vz116))))

test116 : {g:_}-> {a:_} -> Tm116 g (arr116 (arr116 a a) (arr116 a a))
test116  = lam116 (lam116 (app116 v1116 (app116 v1116 (app116 v1116 (app116 v1116 (app116 v1116 (app116 v1116 v0116)))))))
Ty117 : Type
Ty117 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty117 : Ty117
empty117 = \ _, empty, _ => empty

arr117 : Ty117 -> Ty117 -> Ty117
arr117 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con117 : Type
Con117 = (Con117 : Type)
 ->(nil  : Con117)
 ->(snoc : Con117 -> Ty117 -> Con117)
 -> Con117

nil117 : Con117
nil117 = \ con, nil117, snoc => nil117

snoc117 : Con117 -> Ty117 -> Con117
snoc117 = \ g, a, con, nil117, snoc117 => snoc117 (g con nil117 snoc117) a

Var117 : Con117 -> Ty117 -> Type
Var117 = \ g, a =>
    (Var117 : Con117 -> Ty117 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var117 (snoc117 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var117 g a -> Var117 (snoc117 g b) a)
 -> Var117 g a

vz117 : {g : _}-> {a : _} -> Var117 (snoc117 g a) a
vz117 = \ var, vz117, vs => vz117 _ _

vs117 : {g : _} -> {B : _} -> {a : _} -> Var117 g a -> Var117 (snoc117 g B) a
vs117 = \ x, var, vz117, vs117 => vs117 _ _ _ (x var vz117 vs117)

Tm117 : Con117 -> Ty117 -> Type
Tm117 = \ g, a =>
    (Tm117    : Con117 -> Ty117 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var117 g a -> Tm117 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm117 (snoc117 g a) B -> Tm117 g (arr117 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm117 g (arr117 a B) -> Tm117 g a -> Tm117 g B)
 -> Tm117 g a

var117 : {g : _} -> {a : _} -> Var117 g a -> Tm117 g a
var117 = \ x, tm, var117, lam, app => var117 _ _ x

lam117 : {g : _} -> {a : _} -> {B : _} -> Tm117 (snoc117 g a) B -> Tm117 g (arr117 a B)
lam117 = \ t, tm, var117, lam117, app => lam117 _ _ _ (t tm var117 lam117 app)

app117 : {g:_}->{a:_}->{B:_} -> Tm117 g (arr117 a B) -> Tm117 g a -> Tm117 g B
app117 = \ t, u, tm, var117, lam117, app117 => app117 _ _ _ (t tm var117 lam117 app117) (u tm var117 lam117 app117)

v0117 : {g:_}->{a:_} -> Tm117 (snoc117 g a) a
v0117 = var117 vz117

v1117 : {g:_}->{a:_}-> {B:_}-> Tm117 (snoc117 (snoc117 g a) B) a
v1117 = var117 (vs117 vz117)

v2117 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm117 (snoc117 (snoc117 (snoc117 g a) B) C) a
v2117 = var117 (vs117 (vs117 vz117))

v3117 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm117 (snoc117 (snoc117 (snoc117 (snoc117 g a) B) C) D) a
v3117 = var117 (vs117 (vs117 (vs117 vz117)))

v4117 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm117 (snoc117 (snoc117 (snoc117 (snoc117 (snoc117 g a) B) C) D) E) a
v4117 = var117 (vs117 (vs117 (vs117 (vs117 vz117))))

test117 : {g:_}-> {a:_} -> Tm117 g (arr117 (arr117 a a) (arr117 a a))
test117  = lam117 (lam117 (app117 v1117 (app117 v1117 (app117 v1117 (app117 v1117 (app117 v1117 (app117 v1117 v0117)))))))
Ty118 : Type
Ty118 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty118 : Ty118
empty118 = \ _, empty, _ => empty

arr118 : Ty118 -> Ty118 -> Ty118
arr118 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con118 : Type
Con118 = (Con118 : Type)
 ->(nil  : Con118)
 ->(snoc : Con118 -> Ty118 -> Con118)
 -> Con118

nil118 : Con118
nil118 = \ con, nil118, snoc => nil118

snoc118 : Con118 -> Ty118 -> Con118
snoc118 = \ g, a, con, nil118, snoc118 => snoc118 (g con nil118 snoc118) a

Var118 : Con118 -> Ty118 -> Type
Var118 = \ g, a =>
    (Var118 : Con118 -> Ty118 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var118 (snoc118 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var118 g a -> Var118 (snoc118 g b) a)
 -> Var118 g a

vz118 : {g : _}-> {a : _} -> Var118 (snoc118 g a) a
vz118 = \ var, vz118, vs => vz118 _ _

vs118 : {g : _} -> {B : _} -> {a : _} -> Var118 g a -> Var118 (snoc118 g B) a
vs118 = \ x, var, vz118, vs118 => vs118 _ _ _ (x var vz118 vs118)

Tm118 : Con118 -> Ty118 -> Type
Tm118 = \ g, a =>
    (Tm118    : Con118 -> Ty118 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var118 g a -> Tm118 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm118 (snoc118 g a) B -> Tm118 g (arr118 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm118 g (arr118 a B) -> Tm118 g a -> Tm118 g B)
 -> Tm118 g a

var118 : {g : _} -> {a : _} -> Var118 g a -> Tm118 g a
var118 = \ x, tm, var118, lam, app => var118 _ _ x

lam118 : {g : _} -> {a : _} -> {B : _} -> Tm118 (snoc118 g a) B -> Tm118 g (arr118 a B)
lam118 = \ t, tm, var118, lam118, app => lam118 _ _ _ (t tm var118 lam118 app)

app118 : {g:_}->{a:_}->{B:_} -> Tm118 g (arr118 a B) -> Tm118 g a -> Tm118 g B
app118 = \ t, u, tm, var118, lam118, app118 => app118 _ _ _ (t tm var118 lam118 app118) (u tm var118 lam118 app118)

v0118 : {g:_}->{a:_} -> Tm118 (snoc118 g a) a
v0118 = var118 vz118

v1118 : {g:_}->{a:_}-> {B:_}-> Tm118 (snoc118 (snoc118 g a) B) a
v1118 = var118 (vs118 vz118)

v2118 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm118 (snoc118 (snoc118 (snoc118 g a) B) C) a
v2118 = var118 (vs118 (vs118 vz118))

v3118 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm118 (snoc118 (snoc118 (snoc118 (snoc118 g a) B) C) D) a
v3118 = var118 (vs118 (vs118 (vs118 vz118)))

v4118 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm118 (snoc118 (snoc118 (snoc118 (snoc118 (snoc118 g a) B) C) D) E) a
v4118 = var118 (vs118 (vs118 (vs118 (vs118 vz118))))

test118 : {g:_}-> {a:_} -> Tm118 g (arr118 (arr118 a a) (arr118 a a))
test118  = lam118 (lam118 (app118 v1118 (app118 v1118 (app118 v1118 (app118 v1118 (app118 v1118 (app118 v1118 v0118)))))))
Ty119 : Type
Ty119 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty119 : Ty119
empty119 = \ _, empty, _ => empty

arr119 : Ty119 -> Ty119 -> Ty119
arr119 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con119 : Type
Con119 = (Con119 : Type)
 ->(nil  : Con119)
 ->(snoc : Con119 -> Ty119 -> Con119)
 -> Con119

nil119 : Con119
nil119 = \ con, nil119, snoc => nil119

snoc119 : Con119 -> Ty119 -> Con119
snoc119 = \ g, a, con, nil119, snoc119 => snoc119 (g con nil119 snoc119) a

Var119 : Con119 -> Ty119 -> Type
Var119 = \ g, a =>
    (Var119 : Con119 -> Ty119 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var119 (snoc119 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var119 g a -> Var119 (snoc119 g b) a)
 -> Var119 g a

vz119 : {g : _}-> {a : _} -> Var119 (snoc119 g a) a
vz119 = \ var, vz119, vs => vz119 _ _

vs119 : {g : _} -> {B : _} -> {a : _} -> Var119 g a -> Var119 (snoc119 g B) a
vs119 = \ x, var, vz119, vs119 => vs119 _ _ _ (x var vz119 vs119)

Tm119 : Con119 -> Ty119 -> Type
Tm119 = \ g, a =>
    (Tm119    : Con119 -> Ty119 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var119 g a -> Tm119 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm119 (snoc119 g a) B -> Tm119 g (arr119 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm119 g (arr119 a B) -> Tm119 g a -> Tm119 g B)
 -> Tm119 g a

var119 : {g : _} -> {a : _} -> Var119 g a -> Tm119 g a
var119 = \ x, tm, var119, lam, app => var119 _ _ x

lam119 : {g : _} -> {a : _} -> {B : _} -> Tm119 (snoc119 g a) B -> Tm119 g (arr119 a B)
lam119 = \ t, tm, var119, lam119, app => lam119 _ _ _ (t tm var119 lam119 app)

app119 : {g:_}->{a:_}->{B:_} -> Tm119 g (arr119 a B) -> Tm119 g a -> Tm119 g B
app119 = \ t, u, tm, var119, lam119, app119 => app119 _ _ _ (t tm var119 lam119 app119) (u tm var119 lam119 app119)

v0119 : {g:_}->{a:_} -> Tm119 (snoc119 g a) a
v0119 = var119 vz119

v1119 : {g:_}->{a:_}-> {B:_}-> Tm119 (snoc119 (snoc119 g a) B) a
v1119 = var119 (vs119 vz119)

v2119 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm119 (snoc119 (snoc119 (snoc119 g a) B) C) a
v2119 = var119 (vs119 (vs119 vz119))

v3119 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm119 (snoc119 (snoc119 (snoc119 (snoc119 g a) B) C) D) a
v3119 = var119 (vs119 (vs119 (vs119 vz119)))

v4119 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm119 (snoc119 (snoc119 (snoc119 (snoc119 (snoc119 g a) B) C) D) E) a
v4119 = var119 (vs119 (vs119 (vs119 (vs119 vz119))))

test119 : {g:_}-> {a:_} -> Tm119 g (arr119 (arr119 a a) (arr119 a a))
test119  = lam119 (lam119 (app119 v1119 (app119 v1119 (app119 v1119 (app119 v1119 (app119 v1119 (app119 v1119 v0119)))))))
Ty120 : Type
Ty120 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty120 : Ty120
empty120 = \ _, empty, _ => empty

arr120 : Ty120 -> Ty120 -> Ty120
arr120 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con120 : Type
Con120 = (Con120 : Type)
 ->(nil  : Con120)
 ->(snoc : Con120 -> Ty120 -> Con120)
 -> Con120

nil120 : Con120
nil120 = \ con, nil120, snoc => nil120

snoc120 : Con120 -> Ty120 -> Con120
snoc120 = \ g, a, con, nil120, snoc120 => snoc120 (g con nil120 snoc120) a

Var120 : Con120 -> Ty120 -> Type
Var120 = \ g, a =>
    (Var120 : Con120 -> Ty120 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var120 (snoc120 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var120 g a -> Var120 (snoc120 g b) a)
 -> Var120 g a

vz120 : {g : _}-> {a : _} -> Var120 (snoc120 g a) a
vz120 = \ var, vz120, vs => vz120 _ _

vs120 : {g : _} -> {B : _} -> {a : _} -> Var120 g a -> Var120 (snoc120 g B) a
vs120 = \ x, var, vz120, vs120 => vs120 _ _ _ (x var vz120 vs120)

Tm120 : Con120 -> Ty120 -> Type
Tm120 = \ g, a =>
    (Tm120    : Con120 -> Ty120 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var120 g a -> Tm120 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm120 (snoc120 g a) B -> Tm120 g (arr120 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm120 g (arr120 a B) -> Tm120 g a -> Tm120 g B)
 -> Tm120 g a

var120 : {g : _} -> {a : _} -> Var120 g a -> Tm120 g a
var120 = \ x, tm, var120, lam, app => var120 _ _ x

lam120 : {g : _} -> {a : _} -> {B : _} -> Tm120 (snoc120 g a) B -> Tm120 g (arr120 a B)
lam120 = \ t, tm, var120, lam120, app => lam120 _ _ _ (t tm var120 lam120 app)

app120 : {g:_}->{a:_}->{B:_} -> Tm120 g (arr120 a B) -> Tm120 g a -> Tm120 g B
app120 = \ t, u, tm, var120, lam120, app120 => app120 _ _ _ (t tm var120 lam120 app120) (u tm var120 lam120 app120)

v0120 : {g:_}->{a:_} -> Tm120 (snoc120 g a) a
v0120 = var120 vz120

v1120 : {g:_}->{a:_}-> {B:_}-> Tm120 (snoc120 (snoc120 g a) B) a
v1120 = var120 (vs120 vz120)

v2120 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm120 (snoc120 (snoc120 (snoc120 g a) B) C) a
v2120 = var120 (vs120 (vs120 vz120))

v3120 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm120 (snoc120 (snoc120 (snoc120 (snoc120 g a) B) C) D) a
v3120 = var120 (vs120 (vs120 (vs120 vz120)))

v4120 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm120 (snoc120 (snoc120 (snoc120 (snoc120 (snoc120 g a) B) C) D) E) a
v4120 = var120 (vs120 (vs120 (vs120 (vs120 vz120))))

test120 : {g:_}-> {a:_} -> Tm120 g (arr120 (arr120 a a) (arr120 a a))
test120  = lam120 (lam120 (app120 v1120 (app120 v1120 (app120 v1120 (app120 v1120 (app120 v1120 (app120 v1120 v0120)))))))
Ty121 : Type
Ty121 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty121 : Ty121
empty121 = \ _, empty, _ => empty

arr121 : Ty121 -> Ty121 -> Ty121
arr121 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con121 : Type
Con121 = (Con121 : Type)
 ->(nil  : Con121)
 ->(snoc : Con121 -> Ty121 -> Con121)
 -> Con121

nil121 : Con121
nil121 = \ con, nil121, snoc => nil121

snoc121 : Con121 -> Ty121 -> Con121
snoc121 = \ g, a, con, nil121, snoc121 => snoc121 (g con nil121 snoc121) a

Var121 : Con121 -> Ty121 -> Type
Var121 = \ g, a =>
    (Var121 : Con121 -> Ty121 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var121 (snoc121 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var121 g a -> Var121 (snoc121 g b) a)
 -> Var121 g a

vz121 : {g : _}-> {a : _} -> Var121 (snoc121 g a) a
vz121 = \ var, vz121, vs => vz121 _ _

vs121 : {g : _} -> {B : _} -> {a : _} -> Var121 g a -> Var121 (snoc121 g B) a
vs121 = \ x, var, vz121, vs121 => vs121 _ _ _ (x var vz121 vs121)

Tm121 : Con121 -> Ty121 -> Type
Tm121 = \ g, a =>
    (Tm121    : Con121 -> Ty121 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var121 g a -> Tm121 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm121 (snoc121 g a) B -> Tm121 g (arr121 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm121 g (arr121 a B) -> Tm121 g a -> Tm121 g B)
 -> Tm121 g a

var121 : {g : _} -> {a : _} -> Var121 g a -> Tm121 g a
var121 = \ x, tm, var121, lam, app => var121 _ _ x

lam121 : {g : _} -> {a : _} -> {B : _} -> Tm121 (snoc121 g a) B -> Tm121 g (arr121 a B)
lam121 = \ t, tm, var121, lam121, app => lam121 _ _ _ (t tm var121 lam121 app)

app121 : {g:_}->{a:_}->{B:_} -> Tm121 g (arr121 a B) -> Tm121 g a -> Tm121 g B
app121 = \ t, u, tm, var121, lam121, app121 => app121 _ _ _ (t tm var121 lam121 app121) (u tm var121 lam121 app121)

v0121 : {g:_}->{a:_} -> Tm121 (snoc121 g a) a
v0121 = var121 vz121

v1121 : {g:_}->{a:_}-> {B:_}-> Tm121 (snoc121 (snoc121 g a) B) a
v1121 = var121 (vs121 vz121)

v2121 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm121 (snoc121 (snoc121 (snoc121 g a) B) C) a
v2121 = var121 (vs121 (vs121 vz121))

v3121 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm121 (snoc121 (snoc121 (snoc121 (snoc121 g a) B) C) D) a
v3121 = var121 (vs121 (vs121 (vs121 vz121)))

v4121 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm121 (snoc121 (snoc121 (snoc121 (snoc121 (snoc121 g a) B) C) D) E) a
v4121 = var121 (vs121 (vs121 (vs121 (vs121 vz121))))

test121 : {g:_}-> {a:_} -> Tm121 g (arr121 (arr121 a a) (arr121 a a))
test121  = lam121 (lam121 (app121 v1121 (app121 v1121 (app121 v1121 (app121 v1121 (app121 v1121 (app121 v1121 v0121)))))))
Ty122 : Type
Ty122 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty122 : Ty122
empty122 = \ _, empty, _ => empty

arr122 : Ty122 -> Ty122 -> Ty122
arr122 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con122 : Type
Con122 = (Con122 : Type)
 ->(nil  : Con122)
 ->(snoc : Con122 -> Ty122 -> Con122)
 -> Con122

nil122 : Con122
nil122 = \ con, nil122, snoc => nil122

snoc122 : Con122 -> Ty122 -> Con122
snoc122 = \ g, a, con, nil122, snoc122 => snoc122 (g con nil122 snoc122) a

Var122 : Con122 -> Ty122 -> Type
Var122 = \ g, a =>
    (Var122 : Con122 -> Ty122 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var122 (snoc122 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var122 g a -> Var122 (snoc122 g b) a)
 -> Var122 g a

vz122 : {g : _}-> {a : _} -> Var122 (snoc122 g a) a
vz122 = \ var, vz122, vs => vz122 _ _

vs122 : {g : _} -> {B : _} -> {a : _} -> Var122 g a -> Var122 (snoc122 g B) a
vs122 = \ x, var, vz122, vs122 => vs122 _ _ _ (x var vz122 vs122)

Tm122 : Con122 -> Ty122 -> Type
Tm122 = \ g, a =>
    (Tm122    : Con122 -> Ty122 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var122 g a -> Tm122 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm122 (snoc122 g a) B -> Tm122 g (arr122 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm122 g (arr122 a B) -> Tm122 g a -> Tm122 g B)
 -> Tm122 g a

var122 : {g : _} -> {a : _} -> Var122 g a -> Tm122 g a
var122 = \ x, tm, var122, lam, app => var122 _ _ x

lam122 : {g : _} -> {a : _} -> {B : _} -> Tm122 (snoc122 g a) B -> Tm122 g (arr122 a B)
lam122 = \ t, tm, var122, lam122, app => lam122 _ _ _ (t tm var122 lam122 app)

app122 : {g:_}->{a:_}->{B:_} -> Tm122 g (arr122 a B) -> Tm122 g a -> Tm122 g B
app122 = \ t, u, tm, var122, lam122, app122 => app122 _ _ _ (t tm var122 lam122 app122) (u tm var122 lam122 app122)

v0122 : {g:_}->{a:_} -> Tm122 (snoc122 g a) a
v0122 = var122 vz122

v1122 : {g:_}->{a:_}-> {B:_}-> Tm122 (snoc122 (snoc122 g a) B) a
v1122 = var122 (vs122 vz122)

v2122 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm122 (snoc122 (snoc122 (snoc122 g a) B) C) a
v2122 = var122 (vs122 (vs122 vz122))

v3122 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm122 (snoc122 (snoc122 (snoc122 (snoc122 g a) B) C) D) a
v3122 = var122 (vs122 (vs122 (vs122 vz122)))

v4122 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm122 (snoc122 (snoc122 (snoc122 (snoc122 (snoc122 g a) B) C) D) E) a
v4122 = var122 (vs122 (vs122 (vs122 (vs122 vz122))))

test122 : {g:_}-> {a:_} -> Tm122 g (arr122 (arr122 a a) (arr122 a a))
test122  = lam122 (lam122 (app122 v1122 (app122 v1122 (app122 v1122 (app122 v1122 (app122 v1122 (app122 v1122 v0122)))))))
Ty123 : Type
Ty123 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty123 : Ty123
empty123 = \ _, empty, _ => empty

arr123 : Ty123 -> Ty123 -> Ty123
arr123 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con123 : Type
Con123 = (Con123 : Type)
 ->(nil  : Con123)
 ->(snoc : Con123 -> Ty123 -> Con123)
 -> Con123

nil123 : Con123
nil123 = \ con, nil123, snoc => nil123

snoc123 : Con123 -> Ty123 -> Con123
snoc123 = \ g, a, con, nil123, snoc123 => snoc123 (g con nil123 snoc123) a

Var123 : Con123 -> Ty123 -> Type
Var123 = \ g, a =>
    (Var123 : Con123 -> Ty123 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var123 (snoc123 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var123 g a -> Var123 (snoc123 g b) a)
 -> Var123 g a

vz123 : {g : _}-> {a : _} -> Var123 (snoc123 g a) a
vz123 = \ var, vz123, vs => vz123 _ _

vs123 : {g : _} -> {B : _} -> {a : _} -> Var123 g a -> Var123 (snoc123 g B) a
vs123 = \ x, var, vz123, vs123 => vs123 _ _ _ (x var vz123 vs123)

Tm123 : Con123 -> Ty123 -> Type
Tm123 = \ g, a =>
    (Tm123    : Con123 -> Ty123 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var123 g a -> Tm123 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm123 (snoc123 g a) B -> Tm123 g (arr123 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm123 g (arr123 a B) -> Tm123 g a -> Tm123 g B)
 -> Tm123 g a

var123 : {g : _} -> {a : _} -> Var123 g a -> Tm123 g a
var123 = \ x, tm, var123, lam, app => var123 _ _ x

lam123 : {g : _} -> {a : _} -> {B : _} -> Tm123 (snoc123 g a) B -> Tm123 g (arr123 a B)
lam123 = \ t, tm, var123, lam123, app => lam123 _ _ _ (t tm var123 lam123 app)

app123 : {g:_}->{a:_}->{B:_} -> Tm123 g (arr123 a B) -> Tm123 g a -> Tm123 g B
app123 = \ t, u, tm, var123, lam123, app123 => app123 _ _ _ (t tm var123 lam123 app123) (u tm var123 lam123 app123)

v0123 : {g:_}->{a:_} -> Tm123 (snoc123 g a) a
v0123 = var123 vz123

v1123 : {g:_}->{a:_}-> {B:_}-> Tm123 (snoc123 (snoc123 g a) B) a
v1123 = var123 (vs123 vz123)

v2123 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm123 (snoc123 (snoc123 (snoc123 g a) B) C) a
v2123 = var123 (vs123 (vs123 vz123))

v3123 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm123 (snoc123 (snoc123 (snoc123 (snoc123 g a) B) C) D) a
v3123 = var123 (vs123 (vs123 (vs123 vz123)))

v4123 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm123 (snoc123 (snoc123 (snoc123 (snoc123 (snoc123 g a) B) C) D) E) a
v4123 = var123 (vs123 (vs123 (vs123 (vs123 vz123))))

test123 : {g:_}-> {a:_} -> Tm123 g (arr123 (arr123 a a) (arr123 a a))
test123  = lam123 (lam123 (app123 v1123 (app123 v1123 (app123 v1123 (app123 v1123 (app123 v1123 (app123 v1123 v0123)))))))
Ty124 : Type
Ty124 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty124 : Ty124
empty124 = \ _, empty, _ => empty

arr124 : Ty124 -> Ty124 -> Ty124
arr124 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con124 : Type
Con124 = (Con124 : Type)
 ->(nil  : Con124)
 ->(snoc : Con124 -> Ty124 -> Con124)
 -> Con124

nil124 : Con124
nil124 = \ con, nil124, snoc => nil124

snoc124 : Con124 -> Ty124 -> Con124
snoc124 = \ g, a, con, nil124, snoc124 => snoc124 (g con nil124 snoc124) a

Var124 : Con124 -> Ty124 -> Type
Var124 = \ g, a =>
    (Var124 : Con124 -> Ty124 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var124 (snoc124 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var124 g a -> Var124 (snoc124 g b) a)
 -> Var124 g a

vz124 : {g : _}-> {a : _} -> Var124 (snoc124 g a) a
vz124 = \ var, vz124, vs => vz124 _ _

vs124 : {g : _} -> {B : _} -> {a : _} -> Var124 g a -> Var124 (snoc124 g B) a
vs124 = \ x, var, vz124, vs124 => vs124 _ _ _ (x var vz124 vs124)

Tm124 : Con124 -> Ty124 -> Type
Tm124 = \ g, a =>
    (Tm124    : Con124 -> Ty124 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var124 g a -> Tm124 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm124 (snoc124 g a) B -> Tm124 g (arr124 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm124 g (arr124 a B) -> Tm124 g a -> Tm124 g B)
 -> Tm124 g a

var124 : {g : _} -> {a : _} -> Var124 g a -> Tm124 g a
var124 = \ x, tm, var124, lam, app => var124 _ _ x

lam124 : {g : _} -> {a : _} -> {B : _} -> Tm124 (snoc124 g a) B -> Tm124 g (arr124 a B)
lam124 = \ t, tm, var124, lam124, app => lam124 _ _ _ (t tm var124 lam124 app)

app124 : {g:_}->{a:_}->{B:_} -> Tm124 g (arr124 a B) -> Tm124 g a -> Tm124 g B
app124 = \ t, u, tm, var124, lam124, app124 => app124 _ _ _ (t tm var124 lam124 app124) (u tm var124 lam124 app124)

v0124 : {g:_}->{a:_} -> Tm124 (snoc124 g a) a
v0124 = var124 vz124

v1124 : {g:_}->{a:_}-> {B:_}-> Tm124 (snoc124 (snoc124 g a) B) a
v1124 = var124 (vs124 vz124)

v2124 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm124 (snoc124 (snoc124 (snoc124 g a) B) C) a
v2124 = var124 (vs124 (vs124 vz124))

v3124 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm124 (snoc124 (snoc124 (snoc124 (snoc124 g a) B) C) D) a
v3124 = var124 (vs124 (vs124 (vs124 vz124)))

v4124 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm124 (snoc124 (snoc124 (snoc124 (snoc124 (snoc124 g a) B) C) D) E) a
v4124 = var124 (vs124 (vs124 (vs124 (vs124 vz124))))

test124 : {g:_}-> {a:_} -> Tm124 g (arr124 (arr124 a a) (arr124 a a))
test124  = lam124 (lam124 (app124 v1124 (app124 v1124 (app124 v1124 (app124 v1124 (app124 v1124 (app124 v1124 v0124)))))))
Ty125 : Type
Ty125 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty125 : Ty125
empty125 = \ _, empty, _ => empty

arr125 : Ty125 -> Ty125 -> Ty125
arr125 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con125 : Type
Con125 = (Con125 : Type)
 ->(nil  : Con125)
 ->(snoc : Con125 -> Ty125 -> Con125)
 -> Con125

nil125 : Con125
nil125 = \ con, nil125, snoc => nil125

snoc125 : Con125 -> Ty125 -> Con125
snoc125 = \ g, a, con, nil125, snoc125 => snoc125 (g con nil125 snoc125) a

Var125 : Con125 -> Ty125 -> Type
Var125 = \ g, a =>
    (Var125 : Con125 -> Ty125 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var125 (snoc125 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var125 g a -> Var125 (snoc125 g b) a)
 -> Var125 g a

vz125 : {g : _}-> {a : _} -> Var125 (snoc125 g a) a
vz125 = \ var, vz125, vs => vz125 _ _

vs125 : {g : _} -> {B : _} -> {a : _} -> Var125 g a -> Var125 (snoc125 g B) a
vs125 = \ x, var, vz125, vs125 => vs125 _ _ _ (x var vz125 vs125)

Tm125 : Con125 -> Ty125 -> Type
Tm125 = \ g, a =>
    (Tm125    : Con125 -> Ty125 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var125 g a -> Tm125 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm125 (snoc125 g a) B -> Tm125 g (arr125 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm125 g (arr125 a B) -> Tm125 g a -> Tm125 g B)
 -> Tm125 g a

var125 : {g : _} -> {a : _} -> Var125 g a -> Tm125 g a
var125 = \ x, tm, var125, lam, app => var125 _ _ x

lam125 : {g : _} -> {a : _} -> {B : _} -> Tm125 (snoc125 g a) B -> Tm125 g (arr125 a B)
lam125 = \ t, tm, var125, lam125, app => lam125 _ _ _ (t tm var125 lam125 app)

app125 : {g:_}->{a:_}->{B:_} -> Tm125 g (arr125 a B) -> Tm125 g a -> Tm125 g B
app125 = \ t, u, tm, var125, lam125, app125 => app125 _ _ _ (t tm var125 lam125 app125) (u tm var125 lam125 app125)

v0125 : {g:_}->{a:_} -> Tm125 (snoc125 g a) a
v0125 = var125 vz125

v1125 : {g:_}->{a:_}-> {B:_}-> Tm125 (snoc125 (snoc125 g a) B) a
v1125 = var125 (vs125 vz125)

v2125 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm125 (snoc125 (snoc125 (snoc125 g a) B) C) a
v2125 = var125 (vs125 (vs125 vz125))

v3125 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm125 (snoc125 (snoc125 (snoc125 (snoc125 g a) B) C) D) a
v3125 = var125 (vs125 (vs125 (vs125 vz125)))

v4125 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm125 (snoc125 (snoc125 (snoc125 (snoc125 (snoc125 g a) B) C) D) E) a
v4125 = var125 (vs125 (vs125 (vs125 (vs125 vz125))))

test125 : {g:_}-> {a:_} -> Tm125 g (arr125 (arr125 a a) (arr125 a a))
test125  = lam125 (lam125 (app125 v1125 (app125 v1125 (app125 v1125 (app125 v1125 (app125 v1125 (app125 v1125 v0125)))))))
Ty126 : Type
Ty126 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty126 : Ty126
empty126 = \ _, empty, _ => empty

arr126 : Ty126 -> Ty126 -> Ty126
arr126 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con126 : Type
Con126 = (Con126 : Type)
 ->(nil  : Con126)
 ->(snoc : Con126 -> Ty126 -> Con126)
 -> Con126

nil126 : Con126
nil126 = \ con, nil126, snoc => nil126

snoc126 : Con126 -> Ty126 -> Con126
snoc126 = \ g, a, con, nil126, snoc126 => snoc126 (g con nil126 snoc126) a

Var126 : Con126 -> Ty126 -> Type
Var126 = \ g, a =>
    (Var126 : Con126 -> Ty126 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var126 (snoc126 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var126 g a -> Var126 (snoc126 g b) a)
 -> Var126 g a

vz126 : {g : _}-> {a : _} -> Var126 (snoc126 g a) a
vz126 = \ var, vz126, vs => vz126 _ _

vs126 : {g : _} -> {B : _} -> {a : _} -> Var126 g a -> Var126 (snoc126 g B) a
vs126 = \ x, var, vz126, vs126 => vs126 _ _ _ (x var vz126 vs126)

Tm126 : Con126 -> Ty126 -> Type
Tm126 = \ g, a =>
    (Tm126    : Con126 -> Ty126 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var126 g a -> Tm126 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm126 (snoc126 g a) B -> Tm126 g (arr126 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm126 g (arr126 a B) -> Tm126 g a -> Tm126 g B)
 -> Tm126 g a

var126 : {g : _} -> {a : _} -> Var126 g a -> Tm126 g a
var126 = \ x, tm, var126, lam, app => var126 _ _ x

lam126 : {g : _} -> {a : _} -> {B : _} -> Tm126 (snoc126 g a) B -> Tm126 g (arr126 a B)
lam126 = \ t, tm, var126, lam126, app => lam126 _ _ _ (t tm var126 lam126 app)

app126 : {g:_}->{a:_}->{B:_} -> Tm126 g (arr126 a B) -> Tm126 g a -> Tm126 g B
app126 = \ t, u, tm, var126, lam126, app126 => app126 _ _ _ (t tm var126 lam126 app126) (u tm var126 lam126 app126)

v0126 : {g:_}->{a:_} -> Tm126 (snoc126 g a) a
v0126 = var126 vz126

v1126 : {g:_}->{a:_}-> {B:_}-> Tm126 (snoc126 (snoc126 g a) B) a
v1126 = var126 (vs126 vz126)

v2126 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm126 (snoc126 (snoc126 (snoc126 g a) B) C) a
v2126 = var126 (vs126 (vs126 vz126))

v3126 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm126 (snoc126 (snoc126 (snoc126 (snoc126 g a) B) C) D) a
v3126 = var126 (vs126 (vs126 (vs126 vz126)))

v4126 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm126 (snoc126 (snoc126 (snoc126 (snoc126 (snoc126 g a) B) C) D) E) a
v4126 = var126 (vs126 (vs126 (vs126 (vs126 vz126))))

test126 : {g:_}-> {a:_} -> Tm126 g (arr126 (arr126 a a) (arr126 a a))
test126  = lam126 (lam126 (app126 v1126 (app126 v1126 (app126 v1126 (app126 v1126 (app126 v1126 (app126 v1126 v0126)))))))
Ty127 : Type
Ty127 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty127 : Ty127
empty127 = \ _, empty, _ => empty

arr127 : Ty127 -> Ty127 -> Ty127
arr127 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con127 : Type
Con127 = (Con127 : Type)
 ->(nil  : Con127)
 ->(snoc : Con127 -> Ty127 -> Con127)
 -> Con127

nil127 : Con127
nil127 = \ con, nil127, snoc => nil127

snoc127 : Con127 -> Ty127 -> Con127
snoc127 = \ g, a, con, nil127, snoc127 => snoc127 (g con nil127 snoc127) a

Var127 : Con127 -> Ty127 -> Type
Var127 = \ g, a =>
    (Var127 : Con127 -> Ty127 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var127 (snoc127 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var127 g a -> Var127 (snoc127 g b) a)
 -> Var127 g a

vz127 : {g : _}-> {a : _} -> Var127 (snoc127 g a) a
vz127 = \ var, vz127, vs => vz127 _ _

vs127 : {g : _} -> {B : _} -> {a : _} -> Var127 g a -> Var127 (snoc127 g B) a
vs127 = \ x, var, vz127, vs127 => vs127 _ _ _ (x var vz127 vs127)

Tm127 : Con127 -> Ty127 -> Type
Tm127 = \ g, a =>
    (Tm127    : Con127 -> Ty127 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var127 g a -> Tm127 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm127 (snoc127 g a) B -> Tm127 g (arr127 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm127 g (arr127 a B) -> Tm127 g a -> Tm127 g B)
 -> Tm127 g a

var127 : {g : _} -> {a : _} -> Var127 g a -> Tm127 g a
var127 = \ x, tm, var127, lam, app => var127 _ _ x

lam127 : {g : _} -> {a : _} -> {B : _} -> Tm127 (snoc127 g a) B -> Tm127 g (arr127 a B)
lam127 = \ t, tm, var127, lam127, app => lam127 _ _ _ (t tm var127 lam127 app)

app127 : {g:_}->{a:_}->{B:_} -> Tm127 g (arr127 a B) -> Tm127 g a -> Tm127 g B
app127 = \ t, u, tm, var127, lam127, app127 => app127 _ _ _ (t tm var127 lam127 app127) (u tm var127 lam127 app127)

v0127 : {g:_}->{a:_} -> Tm127 (snoc127 g a) a
v0127 = var127 vz127

v1127 : {g:_}->{a:_}-> {B:_}-> Tm127 (snoc127 (snoc127 g a) B) a
v1127 = var127 (vs127 vz127)

v2127 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm127 (snoc127 (snoc127 (snoc127 g a) B) C) a
v2127 = var127 (vs127 (vs127 vz127))

v3127 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm127 (snoc127 (snoc127 (snoc127 (snoc127 g a) B) C) D) a
v3127 = var127 (vs127 (vs127 (vs127 vz127)))

v4127 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm127 (snoc127 (snoc127 (snoc127 (snoc127 (snoc127 g a) B) C) D) E) a
v4127 = var127 (vs127 (vs127 (vs127 (vs127 vz127))))

test127 : {g:_}-> {a:_} -> Tm127 g (arr127 (arr127 a a) (arr127 a a))
test127  = lam127 (lam127 (app127 v1127 (app127 v1127 (app127 v1127 (app127 v1127 (app127 v1127 (app127 v1127 v0127)))))))
Ty128 : Type
Ty128 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty128 : Ty128
empty128 = \ _, empty, _ => empty

arr128 : Ty128 -> Ty128 -> Ty128
arr128 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con128 : Type
Con128 = (Con128 : Type)
 ->(nil  : Con128)
 ->(snoc : Con128 -> Ty128 -> Con128)
 -> Con128

nil128 : Con128
nil128 = \ con, nil128, snoc => nil128

snoc128 : Con128 -> Ty128 -> Con128
snoc128 = \ g, a, con, nil128, snoc128 => snoc128 (g con nil128 snoc128) a

Var128 : Con128 -> Ty128 -> Type
Var128 = \ g, a =>
    (Var128 : Con128 -> Ty128 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var128 (snoc128 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var128 g a -> Var128 (snoc128 g b) a)
 -> Var128 g a

vz128 : {g : _}-> {a : _} -> Var128 (snoc128 g a) a
vz128 = \ var, vz128, vs => vz128 _ _

vs128 : {g : _} -> {B : _} -> {a : _} -> Var128 g a -> Var128 (snoc128 g B) a
vs128 = \ x, var, vz128, vs128 => vs128 _ _ _ (x var vz128 vs128)

Tm128 : Con128 -> Ty128 -> Type
Tm128 = \ g, a =>
    (Tm128    : Con128 -> Ty128 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var128 g a -> Tm128 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm128 (snoc128 g a) B -> Tm128 g (arr128 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm128 g (arr128 a B) -> Tm128 g a -> Tm128 g B)
 -> Tm128 g a

var128 : {g : _} -> {a : _} -> Var128 g a -> Tm128 g a
var128 = \ x, tm, var128, lam, app => var128 _ _ x

lam128 : {g : _} -> {a : _} -> {B : _} -> Tm128 (snoc128 g a) B -> Tm128 g (arr128 a B)
lam128 = \ t, tm, var128, lam128, app => lam128 _ _ _ (t tm var128 lam128 app)

app128 : {g:_}->{a:_}->{B:_} -> Tm128 g (arr128 a B) -> Tm128 g a -> Tm128 g B
app128 = \ t, u, tm, var128, lam128, app128 => app128 _ _ _ (t tm var128 lam128 app128) (u tm var128 lam128 app128)

v0128 : {g:_}->{a:_} -> Tm128 (snoc128 g a) a
v0128 = var128 vz128

v1128 : {g:_}->{a:_}-> {B:_}-> Tm128 (snoc128 (snoc128 g a) B) a
v1128 = var128 (vs128 vz128)

v2128 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm128 (snoc128 (snoc128 (snoc128 g a) B) C) a
v2128 = var128 (vs128 (vs128 vz128))

v3128 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm128 (snoc128 (snoc128 (snoc128 (snoc128 g a) B) C) D) a
v3128 = var128 (vs128 (vs128 (vs128 vz128)))

v4128 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm128 (snoc128 (snoc128 (snoc128 (snoc128 (snoc128 g a) B) C) D) E) a
v4128 = var128 (vs128 (vs128 (vs128 (vs128 vz128))))

test128 : {g:_}-> {a:_} -> Tm128 g (arr128 (arr128 a a) (arr128 a a))
test128  = lam128 (lam128 (app128 v1128 (app128 v1128 (app128 v1128 (app128 v1128 (app128 v1128 (app128 v1128 v0128)))))))
Ty129 : Type
Ty129 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty129 : Ty129
empty129 = \ _, empty, _ => empty

arr129 : Ty129 -> Ty129 -> Ty129
arr129 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con129 : Type
Con129 = (Con129 : Type)
 ->(nil  : Con129)
 ->(snoc : Con129 -> Ty129 -> Con129)
 -> Con129

nil129 : Con129
nil129 = \ con, nil129, snoc => nil129

snoc129 : Con129 -> Ty129 -> Con129
snoc129 = \ g, a, con, nil129, snoc129 => snoc129 (g con nil129 snoc129) a

Var129 : Con129 -> Ty129 -> Type
Var129 = \ g, a =>
    (Var129 : Con129 -> Ty129 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var129 (snoc129 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var129 g a -> Var129 (snoc129 g b) a)
 -> Var129 g a

vz129 : {g : _}-> {a : _} -> Var129 (snoc129 g a) a
vz129 = \ var, vz129, vs => vz129 _ _

vs129 : {g : _} -> {B : _} -> {a : _} -> Var129 g a -> Var129 (snoc129 g B) a
vs129 = \ x, var, vz129, vs129 => vs129 _ _ _ (x var vz129 vs129)

Tm129 : Con129 -> Ty129 -> Type
Tm129 = \ g, a =>
    (Tm129    : Con129 -> Ty129 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var129 g a -> Tm129 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm129 (snoc129 g a) B -> Tm129 g (arr129 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm129 g (arr129 a B) -> Tm129 g a -> Tm129 g B)
 -> Tm129 g a

var129 : {g : _} -> {a : _} -> Var129 g a -> Tm129 g a
var129 = \ x, tm, var129, lam, app => var129 _ _ x

lam129 : {g : _} -> {a : _} -> {B : _} -> Tm129 (snoc129 g a) B -> Tm129 g (arr129 a B)
lam129 = \ t, tm, var129, lam129, app => lam129 _ _ _ (t tm var129 lam129 app)

app129 : {g:_}->{a:_}->{B:_} -> Tm129 g (arr129 a B) -> Tm129 g a -> Tm129 g B
app129 = \ t, u, tm, var129, lam129, app129 => app129 _ _ _ (t tm var129 lam129 app129) (u tm var129 lam129 app129)

v0129 : {g:_}->{a:_} -> Tm129 (snoc129 g a) a
v0129 = var129 vz129

v1129 : {g:_}->{a:_}-> {B:_}-> Tm129 (snoc129 (snoc129 g a) B) a
v1129 = var129 (vs129 vz129)

v2129 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm129 (snoc129 (snoc129 (snoc129 g a) B) C) a
v2129 = var129 (vs129 (vs129 vz129))

v3129 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm129 (snoc129 (snoc129 (snoc129 (snoc129 g a) B) C) D) a
v3129 = var129 (vs129 (vs129 (vs129 vz129)))

v4129 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm129 (snoc129 (snoc129 (snoc129 (snoc129 (snoc129 g a) B) C) D) E) a
v4129 = var129 (vs129 (vs129 (vs129 (vs129 vz129))))

test129 : {g:_}-> {a:_} -> Tm129 g (arr129 (arr129 a a) (arr129 a a))
test129  = lam129 (lam129 (app129 v1129 (app129 v1129 (app129 v1129 (app129 v1129 (app129 v1129 (app129 v1129 v0129)))))))
Ty130 : Type
Ty130 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty130 : Ty130
empty130 = \ _, empty, _ => empty

arr130 : Ty130 -> Ty130 -> Ty130
arr130 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con130 : Type
Con130 = (Con130 : Type)
 ->(nil  : Con130)
 ->(snoc : Con130 -> Ty130 -> Con130)
 -> Con130

nil130 : Con130
nil130 = \ con, nil130, snoc => nil130

snoc130 : Con130 -> Ty130 -> Con130
snoc130 = \ g, a, con, nil130, snoc130 => snoc130 (g con nil130 snoc130) a

Var130 : Con130 -> Ty130 -> Type
Var130 = \ g, a =>
    (Var130 : Con130 -> Ty130 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var130 (snoc130 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var130 g a -> Var130 (snoc130 g b) a)
 -> Var130 g a

vz130 : {g : _}-> {a : _} -> Var130 (snoc130 g a) a
vz130 = \ var, vz130, vs => vz130 _ _

vs130 : {g : _} -> {B : _} -> {a : _} -> Var130 g a -> Var130 (snoc130 g B) a
vs130 = \ x, var, vz130, vs130 => vs130 _ _ _ (x var vz130 vs130)

Tm130 : Con130 -> Ty130 -> Type
Tm130 = \ g, a =>
    (Tm130    : Con130 -> Ty130 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var130 g a -> Tm130 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm130 (snoc130 g a) B -> Tm130 g (arr130 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm130 g (arr130 a B) -> Tm130 g a -> Tm130 g B)
 -> Tm130 g a

var130 : {g : _} -> {a : _} -> Var130 g a -> Tm130 g a
var130 = \ x, tm, var130, lam, app => var130 _ _ x

lam130 : {g : _} -> {a : _} -> {B : _} -> Tm130 (snoc130 g a) B -> Tm130 g (arr130 a B)
lam130 = \ t, tm, var130, lam130, app => lam130 _ _ _ (t tm var130 lam130 app)

app130 : {g:_}->{a:_}->{B:_} -> Tm130 g (arr130 a B) -> Tm130 g a -> Tm130 g B
app130 = \ t, u, tm, var130, lam130, app130 => app130 _ _ _ (t tm var130 lam130 app130) (u tm var130 lam130 app130)

v0130 : {g:_}->{a:_} -> Tm130 (snoc130 g a) a
v0130 = var130 vz130

v1130 : {g:_}->{a:_}-> {B:_}-> Tm130 (snoc130 (snoc130 g a) B) a
v1130 = var130 (vs130 vz130)

v2130 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm130 (snoc130 (snoc130 (snoc130 g a) B) C) a
v2130 = var130 (vs130 (vs130 vz130))

v3130 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm130 (snoc130 (snoc130 (snoc130 (snoc130 g a) B) C) D) a
v3130 = var130 (vs130 (vs130 (vs130 vz130)))

v4130 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm130 (snoc130 (snoc130 (snoc130 (snoc130 (snoc130 g a) B) C) D) E) a
v4130 = var130 (vs130 (vs130 (vs130 (vs130 vz130))))

test130 : {g:_}-> {a:_} -> Tm130 g (arr130 (arr130 a a) (arr130 a a))
test130  = lam130 (lam130 (app130 v1130 (app130 v1130 (app130 v1130 (app130 v1130 (app130 v1130 (app130 v1130 v0130)))))))
Ty131 : Type
Ty131 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty131 : Ty131
empty131 = \ _, empty, _ => empty

arr131 : Ty131 -> Ty131 -> Ty131
arr131 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con131 : Type
Con131 = (Con131 : Type)
 ->(nil  : Con131)
 ->(snoc : Con131 -> Ty131 -> Con131)
 -> Con131

nil131 : Con131
nil131 = \ con, nil131, snoc => nil131

snoc131 : Con131 -> Ty131 -> Con131
snoc131 = \ g, a, con, nil131, snoc131 => snoc131 (g con nil131 snoc131) a

Var131 : Con131 -> Ty131 -> Type
Var131 = \ g, a =>
    (Var131 : Con131 -> Ty131 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var131 (snoc131 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var131 g a -> Var131 (snoc131 g b) a)
 -> Var131 g a

vz131 : {g : _}-> {a : _} -> Var131 (snoc131 g a) a
vz131 = \ var, vz131, vs => vz131 _ _

vs131 : {g : _} -> {B : _} -> {a : _} -> Var131 g a -> Var131 (snoc131 g B) a
vs131 = \ x, var, vz131, vs131 => vs131 _ _ _ (x var vz131 vs131)

Tm131 : Con131 -> Ty131 -> Type
Tm131 = \ g, a =>
    (Tm131    : Con131 -> Ty131 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var131 g a -> Tm131 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm131 (snoc131 g a) B -> Tm131 g (arr131 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm131 g (arr131 a B) -> Tm131 g a -> Tm131 g B)
 -> Tm131 g a

var131 : {g : _} -> {a : _} -> Var131 g a -> Tm131 g a
var131 = \ x, tm, var131, lam, app => var131 _ _ x

lam131 : {g : _} -> {a : _} -> {B : _} -> Tm131 (snoc131 g a) B -> Tm131 g (arr131 a B)
lam131 = \ t, tm, var131, lam131, app => lam131 _ _ _ (t tm var131 lam131 app)

app131 : {g:_}->{a:_}->{B:_} -> Tm131 g (arr131 a B) -> Tm131 g a -> Tm131 g B
app131 = \ t, u, tm, var131, lam131, app131 => app131 _ _ _ (t tm var131 lam131 app131) (u tm var131 lam131 app131)

v0131 : {g:_}->{a:_} -> Tm131 (snoc131 g a) a
v0131 = var131 vz131

v1131 : {g:_}->{a:_}-> {B:_}-> Tm131 (snoc131 (snoc131 g a) B) a
v1131 = var131 (vs131 vz131)

v2131 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm131 (snoc131 (snoc131 (snoc131 g a) B) C) a
v2131 = var131 (vs131 (vs131 vz131))

v3131 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm131 (snoc131 (snoc131 (snoc131 (snoc131 g a) B) C) D) a
v3131 = var131 (vs131 (vs131 (vs131 vz131)))

v4131 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm131 (snoc131 (snoc131 (snoc131 (snoc131 (snoc131 g a) B) C) D) E) a
v4131 = var131 (vs131 (vs131 (vs131 (vs131 vz131))))

test131 : {g:_}-> {a:_} -> Tm131 g (arr131 (arr131 a a) (arr131 a a))
test131  = lam131 (lam131 (app131 v1131 (app131 v1131 (app131 v1131 (app131 v1131 (app131 v1131 (app131 v1131 v0131)))))))
Ty132 : Type
Ty132 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty132 : Ty132
empty132 = \ _, empty, _ => empty

arr132 : Ty132 -> Ty132 -> Ty132
arr132 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con132 : Type
Con132 = (Con132 : Type)
 ->(nil  : Con132)
 ->(snoc : Con132 -> Ty132 -> Con132)
 -> Con132

nil132 : Con132
nil132 = \ con, nil132, snoc => nil132

snoc132 : Con132 -> Ty132 -> Con132
snoc132 = \ g, a, con, nil132, snoc132 => snoc132 (g con nil132 snoc132) a

Var132 : Con132 -> Ty132 -> Type
Var132 = \ g, a =>
    (Var132 : Con132 -> Ty132 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var132 (snoc132 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var132 g a -> Var132 (snoc132 g b) a)
 -> Var132 g a

vz132 : {g : _}-> {a : _} -> Var132 (snoc132 g a) a
vz132 = \ var, vz132, vs => vz132 _ _

vs132 : {g : _} -> {B : _} -> {a : _} -> Var132 g a -> Var132 (snoc132 g B) a
vs132 = \ x, var, vz132, vs132 => vs132 _ _ _ (x var vz132 vs132)

Tm132 : Con132 -> Ty132 -> Type
Tm132 = \ g, a =>
    (Tm132    : Con132 -> Ty132 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var132 g a -> Tm132 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm132 (snoc132 g a) B -> Tm132 g (arr132 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm132 g (arr132 a B) -> Tm132 g a -> Tm132 g B)
 -> Tm132 g a

var132 : {g : _} -> {a : _} -> Var132 g a -> Tm132 g a
var132 = \ x, tm, var132, lam, app => var132 _ _ x

lam132 : {g : _} -> {a : _} -> {B : _} -> Tm132 (snoc132 g a) B -> Tm132 g (arr132 a B)
lam132 = \ t, tm, var132, lam132, app => lam132 _ _ _ (t tm var132 lam132 app)

app132 : {g:_}->{a:_}->{B:_} -> Tm132 g (arr132 a B) -> Tm132 g a -> Tm132 g B
app132 = \ t, u, tm, var132, lam132, app132 => app132 _ _ _ (t tm var132 lam132 app132) (u tm var132 lam132 app132)

v0132 : {g:_}->{a:_} -> Tm132 (snoc132 g a) a
v0132 = var132 vz132

v1132 : {g:_}->{a:_}-> {B:_}-> Tm132 (snoc132 (snoc132 g a) B) a
v1132 = var132 (vs132 vz132)

v2132 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm132 (snoc132 (snoc132 (snoc132 g a) B) C) a
v2132 = var132 (vs132 (vs132 vz132))

v3132 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm132 (snoc132 (snoc132 (snoc132 (snoc132 g a) B) C) D) a
v3132 = var132 (vs132 (vs132 (vs132 vz132)))

v4132 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm132 (snoc132 (snoc132 (snoc132 (snoc132 (snoc132 g a) B) C) D) E) a
v4132 = var132 (vs132 (vs132 (vs132 (vs132 vz132))))

test132 : {g:_}-> {a:_} -> Tm132 g (arr132 (arr132 a a) (arr132 a a))
test132  = lam132 (lam132 (app132 v1132 (app132 v1132 (app132 v1132 (app132 v1132 (app132 v1132 (app132 v1132 v0132)))))))
Ty133 : Type
Ty133 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty133 : Ty133
empty133 = \ _, empty, _ => empty

arr133 : Ty133 -> Ty133 -> Ty133
arr133 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con133 : Type
Con133 = (Con133 : Type)
 ->(nil  : Con133)
 ->(snoc : Con133 -> Ty133 -> Con133)
 -> Con133

nil133 : Con133
nil133 = \ con, nil133, snoc => nil133

snoc133 : Con133 -> Ty133 -> Con133
snoc133 = \ g, a, con, nil133, snoc133 => snoc133 (g con nil133 snoc133) a

Var133 : Con133 -> Ty133 -> Type
Var133 = \ g, a =>
    (Var133 : Con133 -> Ty133 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var133 (snoc133 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var133 g a -> Var133 (snoc133 g b) a)
 -> Var133 g a

vz133 : {g : _}-> {a : _} -> Var133 (snoc133 g a) a
vz133 = \ var, vz133, vs => vz133 _ _

vs133 : {g : _} -> {B : _} -> {a : _} -> Var133 g a -> Var133 (snoc133 g B) a
vs133 = \ x, var, vz133, vs133 => vs133 _ _ _ (x var vz133 vs133)

Tm133 : Con133 -> Ty133 -> Type
Tm133 = \ g, a =>
    (Tm133    : Con133 -> Ty133 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var133 g a -> Tm133 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm133 (snoc133 g a) B -> Tm133 g (arr133 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm133 g (arr133 a B) -> Tm133 g a -> Tm133 g B)
 -> Tm133 g a

var133 : {g : _} -> {a : _} -> Var133 g a -> Tm133 g a
var133 = \ x, tm, var133, lam, app => var133 _ _ x

lam133 : {g : _} -> {a : _} -> {B : _} -> Tm133 (snoc133 g a) B -> Tm133 g (arr133 a B)
lam133 = \ t, tm, var133, lam133, app => lam133 _ _ _ (t tm var133 lam133 app)

app133 : {g:_}->{a:_}->{B:_} -> Tm133 g (arr133 a B) -> Tm133 g a -> Tm133 g B
app133 = \ t, u, tm, var133, lam133, app133 => app133 _ _ _ (t tm var133 lam133 app133) (u tm var133 lam133 app133)

v0133 : {g:_}->{a:_} -> Tm133 (snoc133 g a) a
v0133 = var133 vz133

v1133 : {g:_}->{a:_}-> {B:_}-> Tm133 (snoc133 (snoc133 g a) B) a
v1133 = var133 (vs133 vz133)

v2133 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm133 (snoc133 (snoc133 (snoc133 g a) B) C) a
v2133 = var133 (vs133 (vs133 vz133))

v3133 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm133 (snoc133 (snoc133 (snoc133 (snoc133 g a) B) C) D) a
v3133 = var133 (vs133 (vs133 (vs133 vz133)))

v4133 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm133 (snoc133 (snoc133 (snoc133 (snoc133 (snoc133 g a) B) C) D) E) a
v4133 = var133 (vs133 (vs133 (vs133 (vs133 vz133))))

test133 : {g:_}-> {a:_} -> Tm133 g (arr133 (arr133 a a) (arr133 a a))
test133  = lam133 (lam133 (app133 v1133 (app133 v1133 (app133 v1133 (app133 v1133 (app133 v1133 (app133 v1133 v0133)))))))
Ty134 : Type
Ty134 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty134 : Ty134
empty134 = \ _, empty, _ => empty

arr134 : Ty134 -> Ty134 -> Ty134
arr134 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con134 : Type
Con134 = (Con134 : Type)
 ->(nil  : Con134)
 ->(snoc : Con134 -> Ty134 -> Con134)
 -> Con134

nil134 : Con134
nil134 = \ con, nil134, snoc => nil134

snoc134 : Con134 -> Ty134 -> Con134
snoc134 = \ g, a, con, nil134, snoc134 => snoc134 (g con nil134 snoc134) a

Var134 : Con134 -> Ty134 -> Type
Var134 = \ g, a =>
    (Var134 : Con134 -> Ty134 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var134 (snoc134 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var134 g a -> Var134 (snoc134 g b) a)
 -> Var134 g a

vz134 : {g : _}-> {a : _} -> Var134 (snoc134 g a) a
vz134 = \ var, vz134, vs => vz134 _ _

vs134 : {g : _} -> {B : _} -> {a : _} -> Var134 g a -> Var134 (snoc134 g B) a
vs134 = \ x, var, vz134, vs134 => vs134 _ _ _ (x var vz134 vs134)

Tm134 : Con134 -> Ty134 -> Type
Tm134 = \ g, a =>
    (Tm134    : Con134 -> Ty134 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var134 g a -> Tm134 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm134 (snoc134 g a) B -> Tm134 g (arr134 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm134 g (arr134 a B) -> Tm134 g a -> Tm134 g B)
 -> Tm134 g a

var134 : {g : _} -> {a : _} -> Var134 g a -> Tm134 g a
var134 = \ x, tm, var134, lam, app => var134 _ _ x

lam134 : {g : _} -> {a : _} -> {B : _} -> Tm134 (snoc134 g a) B -> Tm134 g (arr134 a B)
lam134 = \ t, tm, var134, lam134, app => lam134 _ _ _ (t tm var134 lam134 app)

app134 : {g:_}->{a:_}->{B:_} -> Tm134 g (arr134 a B) -> Tm134 g a -> Tm134 g B
app134 = \ t, u, tm, var134, lam134, app134 => app134 _ _ _ (t tm var134 lam134 app134) (u tm var134 lam134 app134)

v0134 : {g:_}->{a:_} -> Tm134 (snoc134 g a) a
v0134 = var134 vz134

v1134 : {g:_}->{a:_}-> {B:_}-> Tm134 (snoc134 (snoc134 g a) B) a
v1134 = var134 (vs134 vz134)

v2134 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm134 (snoc134 (snoc134 (snoc134 g a) B) C) a
v2134 = var134 (vs134 (vs134 vz134))

v3134 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm134 (snoc134 (snoc134 (snoc134 (snoc134 g a) B) C) D) a
v3134 = var134 (vs134 (vs134 (vs134 vz134)))

v4134 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm134 (snoc134 (snoc134 (snoc134 (snoc134 (snoc134 g a) B) C) D) E) a
v4134 = var134 (vs134 (vs134 (vs134 (vs134 vz134))))

test134 : {g:_}-> {a:_} -> Tm134 g (arr134 (arr134 a a) (arr134 a a))
test134  = lam134 (lam134 (app134 v1134 (app134 v1134 (app134 v1134 (app134 v1134 (app134 v1134 (app134 v1134 v0134)))))))
Ty135 : Type
Ty135 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty135 : Ty135
empty135 = \ _, empty, _ => empty

arr135 : Ty135 -> Ty135 -> Ty135
arr135 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con135 : Type
Con135 = (Con135 : Type)
 ->(nil  : Con135)
 ->(snoc : Con135 -> Ty135 -> Con135)
 -> Con135

nil135 : Con135
nil135 = \ con, nil135, snoc => nil135

snoc135 : Con135 -> Ty135 -> Con135
snoc135 = \ g, a, con, nil135, snoc135 => snoc135 (g con nil135 snoc135) a

Var135 : Con135 -> Ty135 -> Type
Var135 = \ g, a =>
    (Var135 : Con135 -> Ty135 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var135 (snoc135 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var135 g a -> Var135 (snoc135 g b) a)
 -> Var135 g a

vz135 : {g : _}-> {a : _} -> Var135 (snoc135 g a) a
vz135 = \ var, vz135, vs => vz135 _ _

vs135 : {g : _} -> {B : _} -> {a : _} -> Var135 g a -> Var135 (snoc135 g B) a
vs135 = \ x, var, vz135, vs135 => vs135 _ _ _ (x var vz135 vs135)

Tm135 : Con135 -> Ty135 -> Type
Tm135 = \ g, a =>
    (Tm135    : Con135 -> Ty135 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var135 g a -> Tm135 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm135 (snoc135 g a) B -> Tm135 g (arr135 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm135 g (arr135 a B) -> Tm135 g a -> Tm135 g B)
 -> Tm135 g a

var135 : {g : _} -> {a : _} -> Var135 g a -> Tm135 g a
var135 = \ x, tm, var135, lam, app => var135 _ _ x

lam135 : {g : _} -> {a : _} -> {B : _} -> Tm135 (snoc135 g a) B -> Tm135 g (arr135 a B)
lam135 = \ t, tm, var135, lam135, app => lam135 _ _ _ (t tm var135 lam135 app)

app135 : {g:_}->{a:_}->{B:_} -> Tm135 g (arr135 a B) -> Tm135 g a -> Tm135 g B
app135 = \ t, u, tm, var135, lam135, app135 => app135 _ _ _ (t tm var135 lam135 app135) (u tm var135 lam135 app135)

v0135 : {g:_}->{a:_} -> Tm135 (snoc135 g a) a
v0135 = var135 vz135

v1135 : {g:_}->{a:_}-> {B:_}-> Tm135 (snoc135 (snoc135 g a) B) a
v1135 = var135 (vs135 vz135)

v2135 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm135 (snoc135 (snoc135 (snoc135 g a) B) C) a
v2135 = var135 (vs135 (vs135 vz135))

v3135 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm135 (snoc135 (snoc135 (snoc135 (snoc135 g a) B) C) D) a
v3135 = var135 (vs135 (vs135 (vs135 vz135)))

v4135 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm135 (snoc135 (snoc135 (snoc135 (snoc135 (snoc135 g a) B) C) D) E) a
v4135 = var135 (vs135 (vs135 (vs135 (vs135 vz135))))

test135 : {g:_}-> {a:_} -> Tm135 g (arr135 (arr135 a a) (arr135 a a))
test135  = lam135 (lam135 (app135 v1135 (app135 v1135 (app135 v1135 (app135 v1135 (app135 v1135 (app135 v1135 v0135)))))))
Ty136 : Type
Ty136 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty136 : Ty136
empty136 = \ _, empty, _ => empty

arr136 : Ty136 -> Ty136 -> Ty136
arr136 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con136 : Type
Con136 = (Con136 : Type)
 ->(nil  : Con136)
 ->(snoc : Con136 -> Ty136 -> Con136)
 -> Con136

nil136 : Con136
nil136 = \ con, nil136, snoc => nil136

snoc136 : Con136 -> Ty136 -> Con136
snoc136 = \ g, a, con, nil136, snoc136 => snoc136 (g con nil136 snoc136) a

Var136 : Con136 -> Ty136 -> Type
Var136 = \ g, a =>
    (Var136 : Con136 -> Ty136 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var136 (snoc136 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var136 g a -> Var136 (snoc136 g b) a)
 -> Var136 g a

vz136 : {g : _}-> {a : _} -> Var136 (snoc136 g a) a
vz136 = \ var, vz136, vs => vz136 _ _

vs136 : {g : _} -> {B : _} -> {a : _} -> Var136 g a -> Var136 (snoc136 g B) a
vs136 = \ x, var, vz136, vs136 => vs136 _ _ _ (x var vz136 vs136)

Tm136 : Con136 -> Ty136 -> Type
Tm136 = \ g, a =>
    (Tm136    : Con136 -> Ty136 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var136 g a -> Tm136 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm136 (snoc136 g a) B -> Tm136 g (arr136 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm136 g (arr136 a B) -> Tm136 g a -> Tm136 g B)
 -> Tm136 g a

var136 : {g : _} -> {a : _} -> Var136 g a -> Tm136 g a
var136 = \ x, tm, var136, lam, app => var136 _ _ x

lam136 : {g : _} -> {a : _} -> {B : _} -> Tm136 (snoc136 g a) B -> Tm136 g (arr136 a B)
lam136 = \ t, tm, var136, lam136, app => lam136 _ _ _ (t tm var136 lam136 app)

app136 : {g:_}->{a:_}->{B:_} -> Tm136 g (arr136 a B) -> Tm136 g a -> Tm136 g B
app136 = \ t, u, tm, var136, lam136, app136 => app136 _ _ _ (t tm var136 lam136 app136) (u tm var136 lam136 app136)

v0136 : {g:_}->{a:_} -> Tm136 (snoc136 g a) a
v0136 = var136 vz136

v1136 : {g:_}->{a:_}-> {B:_}-> Tm136 (snoc136 (snoc136 g a) B) a
v1136 = var136 (vs136 vz136)

v2136 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm136 (snoc136 (snoc136 (snoc136 g a) B) C) a
v2136 = var136 (vs136 (vs136 vz136))

v3136 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm136 (snoc136 (snoc136 (snoc136 (snoc136 g a) B) C) D) a
v3136 = var136 (vs136 (vs136 (vs136 vz136)))

v4136 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm136 (snoc136 (snoc136 (snoc136 (snoc136 (snoc136 g a) B) C) D) E) a
v4136 = var136 (vs136 (vs136 (vs136 (vs136 vz136))))

test136 : {g:_}-> {a:_} -> Tm136 g (arr136 (arr136 a a) (arr136 a a))
test136  = lam136 (lam136 (app136 v1136 (app136 v1136 (app136 v1136 (app136 v1136 (app136 v1136 (app136 v1136 v0136)))))))
Ty137 : Type
Ty137 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty137 : Ty137
empty137 = \ _, empty, _ => empty

arr137 : Ty137 -> Ty137 -> Ty137
arr137 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con137 : Type
Con137 = (Con137 : Type)
 ->(nil  : Con137)
 ->(snoc : Con137 -> Ty137 -> Con137)
 -> Con137

nil137 : Con137
nil137 = \ con, nil137, snoc => nil137

snoc137 : Con137 -> Ty137 -> Con137
snoc137 = \ g, a, con, nil137, snoc137 => snoc137 (g con nil137 snoc137) a

Var137 : Con137 -> Ty137 -> Type
Var137 = \ g, a =>
    (Var137 : Con137 -> Ty137 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var137 (snoc137 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var137 g a -> Var137 (snoc137 g b) a)
 -> Var137 g a

vz137 : {g : _}-> {a : _} -> Var137 (snoc137 g a) a
vz137 = \ var, vz137, vs => vz137 _ _

vs137 : {g : _} -> {B : _} -> {a : _} -> Var137 g a -> Var137 (snoc137 g B) a
vs137 = \ x, var, vz137, vs137 => vs137 _ _ _ (x var vz137 vs137)

Tm137 : Con137 -> Ty137 -> Type
Tm137 = \ g, a =>
    (Tm137    : Con137 -> Ty137 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var137 g a -> Tm137 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm137 (snoc137 g a) B -> Tm137 g (arr137 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm137 g (arr137 a B) -> Tm137 g a -> Tm137 g B)
 -> Tm137 g a

var137 : {g : _} -> {a : _} -> Var137 g a -> Tm137 g a
var137 = \ x, tm, var137, lam, app => var137 _ _ x

lam137 : {g : _} -> {a : _} -> {B : _} -> Tm137 (snoc137 g a) B -> Tm137 g (arr137 a B)
lam137 = \ t, tm, var137, lam137, app => lam137 _ _ _ (t tm var137 lam137 app)

app137 : {g:_}->{a:_}->{B:_} -> Tm137 g (arr137 a B) -> Tm137 g a -> Tm137 g B
app137 = \ t, u, tm, var137, lam137, app137 => app137 _ _ _ (t tm var137 lam137 app137) (u tm var137 lam137 app137)

v0137 : {g:_}->{a:_} -> Tm137 (snoc137 g a) a
v0137 = var137 vz137

v1137 : {g:_}->{a:_}-> {B:_}-> Tm137 (snoc137 (snoc137 g a) B) a
v1137 = var137 (vs137 vz137)

v2137 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm137 (snoc137 (snoc137 (snoc137 g a) B) C) a
v2137 = var137 (vs137 (vs137 vz137))

v3137 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm137 (snoc137 (snoc137 (snoc137 (snoc137 g a) B) C) D) a
v3137 = var137 (vs137 (vs137 (vs137 vz137)))

v4137 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm137 (snoc137 (snoc137 (snoc137 (snoc137 (snoc137 g a) B) C) D) E) a
v4137 = var137 (vs137 (vs137 (vs137 (vs137 vz137))))

test137 : {g:_}-> {a:_} -> Tm137 g (arr137 (arr137 a a) (arr137 a a))
test137  = lam137 (lam137 (app137 v1137 (app137 v1137 (app137 v1137 (app137 v1137 (app137 v1137 (app137 v1137 v0137)))))))
Ty138 : Type
Ty138 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty138 : Ty138
empty138 = \ _, empty, _ => empty

arr138 : Ty138 -> Ty138 -> Ty138
arr138 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con138 : Type
Con138 = (Con138 : Type)
 ->(nil  : Con138)
 ->(snoc : Con138 -> Ty138 -> Con138)
 -> Con138

nil138 : Con138
nil138 = \ con, nil138, snoc => nil138

snoc138 : Con138 -> Ty138 -> Con138
snoc138 = \ g, a, con, nil138, snoc138 => snoc138 (g con nil138 snoc138) a

Var138 : Con138 -> Ty138 -> Type
Var138 = \ g, a =>
    (Var138 : Con138 -> Ty138 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var138 (snoc138 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var138 g a -> Var138 (snoc138 g b) a)
 -> Var138 g a

vz138 : {g : _}-> {a : _} -> Var138 (snoc138 g a) a
vz138 = \ var, vz138, vs => vz138 _ _

vs138 : {g : _} -> {B : _} -> {a : _} -> Var138 g a -> Var138 (snoc138 g B) a
vs138 = \ x, var, vz138, vs138 => vs138 _ _ _ (x var vz138 vs138)

Tm138 : Con138 -> Ty138 -> Type
Tm138 = \ g, a =>
    (Tm138    : Con138 -> Ty138 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var138 g a -> Tm138 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm138 (snoc138 g a) B -> Tm138 g (arr138 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm138 g (arr138 a B) -> Tm138 g a -> Tm138 g B)
 -> Tm138 g a

var138 : {g : _} -> {a : _} -> Var138 g a -> Tm138 g a
var138 = \ x, tm, var138, lam, app => var138 _ _ x

lam138 : {g : _} -> {a : _} -> {B : _} -> Tm138 (snoc138 g a) B -> Tm138 g (arr138 a B)
lam138 = \ t, tm, var138, lam138, app => lam138 _ _ _ (t tm var138 lam138 app)

app138 : {g:_}->{a:_}->{B:_} -> Tm138 g (arr138 a B) -> Tm138 g a -> Tm138 g B
app138 = \ t, u, tm, var138, lam138, app138 => app138 _ _ _ (t tm var138 lam138 app138) (u tm var138 lam138 app138)

v0138 : {g:_}->{a:_} -> Tm138 (snoc138 g a) a
v0138 = var138 vz138

v1138 : {g:_}->{a:_}-> {B:_}-> Tm138 (snoc138 (snoc138 g a) B) a
v1138 = var138 (vs138 vz138)

v2138 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm138 (snoc138 (snoc138 (snoc138 g a) B) C) a
v2138 = var138 (vs138 (vs138 vz138))

v3138 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm138 (snoc138 (snoc138 (snoc138 (snoc138 g a) B) C) D) a
v3138 = var138 (vs138 (vs138 (vs138 vz138)))

v4138 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm138 (snoc138 (snoc138 (snoc138 (snoc138 (snoc138 g a) B) C) D) E) a
v4138 = var138 (vs138 (vs138 (vs138 (vs138 vz138))))

test138 : {g:_}-> {a:_} -> Tm138 g (arr138 (arr138 a a) (arr138 a a))
test138  = lam138 (lam138 (app138 v1138 (app138 v1138 (app138 v1138 (app138 v1138 (app138 v1138 (app138 v1138 v0138)))))))
Ty139 : Type
Ty139 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty139 : Ty139
empty139 = \ _, empty, _ => empty

arr139 : Ty139 -> Ty139 -> Ty139
arr139 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con139 : Type
Con139 = (Con139 : Type)
 ->(nil  : Con139)
 ->(snoc : Con139 -> Ty139 -> Con139)
 -> Con139

nil139 : Con139
nil139 = \ con, nil139, snoc => nil139

snoc139 : Con139 -> Ty139 -> Con139
snoc139 = \ g, a, con, nil139, snoc139 => snoc139 (g con nil139 snoc139) a

Var139 : Con139 -> Ty139 -> Type
Var139 = \ g, a =>
    (Var139 : Con139 -> Ty139 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var139 (snoc139 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var139 g a -> Var139 (snoc139 g b) a)
 -> Var139 g a

vz139 : {g : _}-> {a : _} -> Var139 (snoc139 g a) a
vz139 = \ var, vz139, vs => vz139 _ _

vs139 : {g : _} -> {B : _} -> {a : _} -> Var139 g a -> Var139 (snoc139 g B) a
vs139 = \ x, var, vz139, vs139 => vs139 _ _ _ (x var vz139 vs139)

Tm139 : Con139 -> Ty139 -> Type
Tm139 = \ g, a =>
    (Tm139    : Con139 -> Ty139 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var139 g a -> Tm139 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm139 (snoc139 g a) B -> Tm139 g (arr139 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm139 g (arr139 a B) -> Tm139 g a -> Tm139 g B)
 -> Tm139 g a

var139 : {g : _} -> {a : _} -> Var139 g a -> Tm139 g a
var139 = \ x, tm, var139, lam, app => var139 _ _ x

lam139 : {g : _} -> {a : _} -> {B : _} -> Tm139 (snoc139 g a) B -> Tm139 g (arr139 a B)
lam139 = \ t, tm, var139, lam139, app => lam139 _ _ _ (t tm var139 lam139 app)

app139 : {g:_}->{a:_}->{B:_} -> Tm139 g (arr139 a B) -> Tm139 g a -> Tm139 g B
app139 = \ t, u, tm, var139, lam139, app139 => app139 _ _ _ (t tm var139 lam139 app139) (u tm var139 lam139 app139)

v0139 : {g:_}->{a:_} -> Tm139 (snoc139 g a) a
v0139 = var139 vz139

v1139 : {g:_}->{a:_}-> {B:_}-> Tm139 (snoc139 (snoc139 g a) B) a
v1139 = var139 (vs139 vz139)

v2139 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm139 (snoc139 (snoc139 (snoc139 g a) B) C) a
v2139 = var139 (vs139 (vs139 vz139))

v3139 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm139 (snoc139 (snoc139 (snoc139 (snoc139 g a) B) C) D) a
v3139 = var139 (vs139 (vs139 (vs139 vz139)))

v4139 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm139 (snoc139 (snoc139 (snoc139 (snoc139 (snoc139 g a) B) C) D) E) a
v4139 = var139 (vs139 (vs139 (vs139 (vs139 vz139))))

test139 : {g:_}-> {a:_} -> Tm139 g (arr139 (arr139 a a) (arr139 a a))
test139  = lam139 (lam139 (app139 v1139 (app139 v1139 (app139 v1139 (app139 v1139 (app139 v1139 (app139 v1139 v0139)))))))
Ty140 : Type
Ty140 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty140 : Ty140
empty140 = \ _, empty, _ => empty

arr140 : Ty140 -> Ty140 -> Ty140
arr140 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con140 : Type
Con140 = (Con140 : Type)
 ->(nil  : Con140)
 ->(snoc : Con140 -> Ty140 -> Con140)
 -> Con140

nil140 : Con140
nil140 = \ con, nil140, snoc => nil140

snoc140 : Con140 -> Ty140 -> Con140
snoc140 = \ g, a, con, nil140, snoc140 => snoc140 (g con nil140 snoc140) a

Var140 : Con140 -> Ty140 -> Type
Var140 = \ g, a =>
    (Var140 : Con140 -> Ty140 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var140 (snoc140 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var140 g a -> Var140 (snoc140 g b) a)
 -> Var140 g a

vz140 : {g : _}-> {a : _} -> Var140 (snoc140 g a) a
vz140 = \ var, vz140, vs => vz140 _ _

vs140 : {g : _} -> {B : _} -> {a : _} -> Var140 g a -> Var140 (snoc140 g B) a
vs140 = \ x, var, vz140, vs140 => vs140 _ _ _ (x var vz140 vs140)

Tm140 : Con140 -> Ty140 -> Type
Tm140 = \ g, a =>
    (Tm140    : Con140 -> Ty140 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var140 g a -> Tm140 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm140 (snoc140 g a) B -> Tm140 g (arr140 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm140 g (arr140 a B) -> Tm140 g a -> Tm140 g B)
 -> Tm140 g a

var140 : {g : _} -> {a : _} -> Var140 g a -> Tm140 g a
var140 = \ x, tm, var140, lam, app => var140 _ _ x

lam140 : {g : _} -> {a : _} -> {B : _} -> Tm140 (snoc140 g a) B -> Tm140 g (arr140 a B)
lam140 = \ t, tm, var140, lam140, app => lam140 _ _ _ (t tm var140 lam140 app)

app140 : {g:_}->{a:_}->{B:_} -> Tm140 g (arr140 a B) -> Tm140 g a -> Tm140 g B
app140 = \ t, u, tm, var140, lam140, app140 => app140 _ _ _ (t tm var140 lam140 app140) (u tm var140 lam140 app140)

v0140 : {g:_}->{a:_} -> Tm140 (snoc140 g a) a
v0140 = var140 vz140

v1140 : {g:_}->{a:_}-> {B:_}-> Tm140 (snoc140 (snoc140 g a) B) a
v1140 = var140 (vs140 vz140)

v2140 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm140 (snoc140 (snoc140 (snoc140 g a) B) C) a
v2140 = var140 (vs140 (vs140 vz140))

v3140 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm140 (snoc140 (snoc140 (snoc140 (snoc140 g a) B) C) D) a
v3140 = var140 (vs140 (vs140 (vs140 vz140)))

v4140 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm140 (snoc140 (snoc140 (snoc140 (snoc140 (snoc140 g a) B) C) D) E) a
v4140 = var140 (vs140 (vs140 (vs140 (vs140 vz140))))

test140 : {g:_}-> {a:_} -> Tm140 g (arr140 (arr140 a a) (arr140 a a))
test140  = lam140 (lam140 (app140 v1140 (app140 v1140 (app140 v1140 (app140 v1140 (app140 v1140 (app140 v1140 v0140)))))))
Ty141 : Type
Ty141 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty141 : Ty141
empty141 = \ _, empty, _ => empty

arr141 : Ty141 -> Ty141 -> Ty141
arr141 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con141 : Type
Con141 = (Con141 : Type)
 ->(nil  : Con141)
 ->(snoc : Con141 -> Ty141 -> Con141)
 -> Con141

nil141 : Con141
nil141 = \ con, nil141, snoc => nil141

snoc141 : Con141 -> Ty141 -> Con141
snoc141 = \ g, a, con, nil141, snoc141 => snoc141 (g con nil141 snoc141) a

Var141 : Con141 -> Ty141 -> Type
Var141 = \ g, a =>
    (Var141 : Con141 -> Ty141 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var141 (snoc141 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var141 g a -> Var141 (snoc141 g b) a)
 -> Var141 g a

vz141 : {g : _}-> {a : _} -> Var141 (snoc141 g a) a
vz141 = \ var, vz141, vs => vz141 _ _

vs141 : {g : _} -> {B : _} -> {a : _} -> Var141 g a -> Var141 (snoc141 g B) a
vs141 = \ x, var, vz141, vs141 => vs141 _ _ _ (x var vz141 vs141)

Tm141 : Con141 -> Ty141 -> Type
Tm141 = \ g, a =>
    (Tm141    : Con141 -> Ty141 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var141 g a -> Tm141 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm141 (snoc141 g a) B -> Tm141 g (arr141 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm141 g (arr141 a B) -> Tm141 g a -> Tm141 g B)
 -> Tm141 g a

var141 : {g : _} -> {a : _} -> Var141 g a -> Tm141 g a
var141 = \ x, tm, var141, lam, app => var141 _ _ x

lam141 : {g : _} -> {a : _} -> {B : _} -> Tm141 (snoc141 g a) B -> Tm141 g (arr141 a B)
lam141 = \ t, tm, var141, lam141, app => lam141 _ _ _ (t tm var141 lam141 app)

app141 : {g:_}->{a:_}->{B:_} -> Tm141 g (arr141 a B) -> Tm141 g a -> Tm141 g B
app141 = \ t, u, tm, var141, lam141, app141 => app141 _ _ _ (t tm var141 lam141 app141) (u tm var141 lam141 app141)

v0141 : {g:_}->{a:_} -> Tm141 (snoc141 g a) a
v0141 = var141 vz141

v1141 : {g:_}->{a:_}-> {B:_}-> Tm141 (snoc141 (snoc141 g a) B) a
v1141 = var141 (vs141 vz141)

v2141 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm141 (snoc141 (snoc141 (snoc141 g a) B) C) a
v2141 = var141 (vs141 (vs141 vz141))

v3141 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm141 (snoc141 (snoc141 (snoc141 (snoc141 g a) B) C) D) a
v3141 = var141 (vs141 (vs141 (vs141 vz141)))

v4141 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm141 (snoc141 (snoc141 (snoc141 (snoc141 (snoc141 g a) B) C) D) E) a
v4141 = var141 (vs141 (vs141 (vs141 (vs141 vz141))))

test141 : {g:_}-> {a:_} -> Tm141 g (arr141 (arr141 a a) (arr141 a a))
test141  = lam141 (lam141 (app141 v1141 (app141 v1141 (app141 v1141 (app141 v1141 (app141 v1141 (app141 v1141 v0141)))))))
Ty142 : Type
Ty142 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty142 : Ty142
empty142 = \ _, empty, _ => empty

arr142 : Ty142 -> Ty142 -> Ty142
arr142 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con142 : Type
Con142 = (Con142 : Type)
 ->(nil  : Con142)
 ->(snoc : Con142 -> Ty142 -> Con142)
 -> Con142

nil142 : Con142
nil142 = \ con, nil142, snoc => nil142

snoc142 : Con142 -> Ty142 -> Con142
snoc142 = \ g, a, con, nil142, snoc142 => snoc142 (g con nil142 snoc142) a

Var142 : Con142 -> Ty142 -> Type
Var142 = \ g, a =>
    (Var142 : Con142 -> Ty142 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var142 (snoc142 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var142 g a -> Var142 (snoc142 g b) a)
 -> Var142 g a

vz142 : {g : _}-> {a : _} -> Var142 (snoc142 g a) a
vz142 = \ var, vz142, vs => vz142 _ _

vs142 : {g : _} -> {B : _} -> {a : _} -> Var142 g a -> Var142 (snoc142 g B) a
vs142 = \ x, var, vz142, vs142 => vs142 _ _ _ (x var vz142 vs142)

Tm142 : Con142 -> Ty142 -> Type
Tm142 = \ g, a =>
    (Tm142    : Con142 -> Ty142 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var142 g a -> Tm142 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm142 (snoc142 g a) B -> Tm142 g (arr142 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm142 g (arr142 a B) -> Tm142 g a -> Tm142 g B)
 -> Tm142 g a

var142 : {g : _} -> {a : _} -> Var142 g a -> Tm142 g a
var142 = \ x, tm, var142, lam, app => var142 _ _ x

lam142 : {g : _} -> {a : _} -> {B : _} -> Tm142 (snoc142 g a) B -> Tm142 g (arr142 a B)
lam142 = \ t, tm, var142, lam142, app => lam142 _ _ _ (t tm var142 lam142 app)

app142 : {g:_}->{a:_}->{B:_} -> Tm142 g (arr142 a B) -> Tm142 g a -> Tm142 g B
app142 = \ t, u, tm, var142, lam142, app142 => app142 _ _ _ (t tm var142 lam142 app142) (u tm var142 lam142 app142)

v0142 : {g:_}->{a:_} -> Tm142 (snoc142 g a) a
v0142 = var142 vz142

v1142 : {g:_}->{a:_}-> {B:_}-> Tm142 (snoc142 (snoc142 g a) B) a
v1142 = var142 (vs142 vz142)

v2142 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm142 (snoc142 (snoc142 (snoc142 g a) B) C) a
v2142 = var142 (vs142 (vs142 vz142))

v3142 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm142 (snoc142 (snoc142 (snoc142 (snoc142 g a) B) C) D) a
v3142 = var142 (vs142 (vs142 (vs142 vz142)))

v4142 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm142 (snoc142 (snoc142 (snoc142 (snoc142 (snoc142 g a) B) C) D) E) a
v4142 = var142 (vs142 (vs142 (vs142 (vs142 vz142))))

test142 : {g:_}-> {a:_} -> Tm142 g (arr142 (arr142 a a) (arr142 a a))
test142  = lam142 (lam142 (app142 v1142 (app142 v1142 (app142 v1142 (app142 v1142 (app142 v1142 (app142 v1142 v0142)))))))
Ty143 : Type
Ty143 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty143 : Ty143
empty143 = \ _, empty, _ => empty

arr143 : Ty143 -> Ty143 -> Ty143
arr143 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con143 : Type
Con143 = (Con143 : Type)
 ->(nil  : Con143)
 ->(snoc : Con143 -> Ty143 -> Con143)
 -> Con143

nil143 : Con143
nil143 = \ con, nil143, snoc => nil143

snoc143 : Con143 -> Ty143 -> Con143
snoc143 = \ g, a, con, nil143, snoc143 => snoc143 (g con nil143 snoc143) a

Var143 : Con143 -> Ty143 -> Type
Var143 = \ g, a =>
    (Var143 : Con143 -> Ty143 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var143 (snoc143 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var143 g a -> Var143 (snoc143 g b) a)
 -> Var143 g a

vz143 : {g : _}-> {a : _} -> Var143 (snoc143 g a) a
vz143 = \ var, vz143, vs => vz143 _ _

vs143 : {g : _} -> {B : _} -> {a : _} -> Var143 g a -> Var143 (snoc143 g B) a
vs143 = \ x, var, vz143, vs143 => vs143 _ _ _ (x var vz143 vs143)

Tm143 : Con143 -> Ty143 -> Type
Tm143 = \ g, a =>
    (Tm143    : Con143 -> Ty143 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var143 g a -> Tm143 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm143 (snoc143 g a) B -> Tm143 g (arr143 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm143 g (arr143 a B) -> Tm143 g a -> Tm143 g B)
 -> Tm143 g a

var143 : {g : _} -> {a : _} -> Var143 g a -> Tm143 g a
var143 = \ x, tm, var143, lam, app => var143 _ _ x

lam143 : {g : _} -> {a : _} -> {B : _} -> Tm143 (snoc143 g a) B -> Tm143 g (arr143 a B)
lam143 = \ t, tm, var143, lam143, app => lam143 _ _ _ (t tm var143 lam143 app)

app143 : {g:_}->{a:_}->{B:_} -> Tm143 g (arr143 a B) -> Tm143 g a -> Tm143 g B
app143 = \ t, u, tm, var143, lam143, app143 => app143 _ _ _ (t tm var143 lam143 app143) (u tm var143 lam143 app143)

v0143 : {g:_}->{a:_} -> Tm143 (snoc143 g a) a
v0143 = var143 vz143

v1143 : {g:_}->{a:_}-> {B:_}-> Tm143 (snoc143 (snoc143 g a) B) a
v1143 = var143 (vs143 vz143)

v2143 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm143 (snoc143 (snoc143 (snoc143 g a) B) C) a
v2143 = var143 (vs143 (vs143 vz143))

v3143 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm143 (snoc143 (snoc143 (snoc143 (snoc143 g a) B) C) D) a
v3143 = var143 (vs143 (vs143 (vs143 vz143)))

v4143 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm143 (snoc143 (snoc143 (snoc143 (snoc143 (snoc143 g a) B) C) D) E) a
v4143 = var143 (vs143 (vs143 (vs143 (vs143 vz143))))

test143 : {g:_}-> {a:_} -> Tm143 g (arr143 (arr143 a a) (arr143 a a))
test143  = lam143 (lam143 (app143 v1143 (app143 v1143 (app143 v1143 (app143 v1143 (app143 v1143 (app143 v1143 v0143)))))))
Ty144 : Type
Ty144 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty144 : Ty144
empty144 = \ _, empty, _ => empty

arr144 : Ty144 -> Ty144 -> Ty144
arr144 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con144 : Type
Con144 = (Con144 : Type)
 ->(nil  : Con144)
 ->(snoc : Con144 -> Ty144 -> Con144)
 -> Con144

nil144 : Con144
nil144 = \ con, nil144, snoc => nil144

snoc144 : Con144 -> Ty144 -> Con144
snoc144 = \ g, a, con, nil144, snoc144 => snoc144 (g con nil144 snoc144) a

Var144 : Con144 -> Ty144 -> Type
Var144 = \ g, a =>
    (Var144 : Con144 -> Ty144 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var144 (snoc144 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var144 g a -> Var144 (snoc144 g b) a)
 -> Var144 g a

vz144 : {g : _}-> {a : _} -> Var144 (snoc144 g a) a
vz144 = \ var, vz144, vs => vz144 _ _

vs144 : {g : _} -> {B : _} -> {a : _} -> Var144 g a -> Var144 (snoc144 g B) a
vs144 = \ x, var, vz144, vs144 => vs144 _ _ _ (x var vz144 vs144)

Tm144 : Con144 -> Ty144 -> Type
Tm144 = \ g, a =>
    (Tm144    : Con144 -> Ty144 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var144 g a -> Tm144 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm144 (snoc144 g a) B -> Tm144 g (arr144 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm144 g (arr144 a B) -> Tm144 g a -> Tm144 g B)
 -> Tm144 g a

var144 : {g : _} -> {a : _} -> Var144 g a -> Tm144 g a
var144 = \ x, tm, var144, lam, app => var144 _ _ x

lam144 : {g : _} -> {a : _} -> {B : _} -> Tm144 (snoc144 g a) B -> Tm144 g (arr144 a B)
lam144 = \ t, tm, var144, lam144, app => lam144 _ _ _ (t tm var144 lam144 app)

app144 : {g:_}->{a:_}->{B:_} -> Tm144 g (arr144 a B) -> Tm144 g a -> Tm144 g B
app144 = \ t, u, tm, var144, lam144, app144 => app144 _ _ _ (t tm var144 lam144 app144) (u tm var144 lam144 app144)

v0144 : {g:_}->{a:_} -> Tm144 (snoc144 g a) a
v0144 = var144 vz144

v1144 : {g:_}->{a:_}-> {B:_}-> Tm144 (snoc144 (snoc144 g a) B) a
v1144 = var144 (vs144 vz144)

v2144 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm144 (snoc144 (snoc144 (snoc144 g a) B) C) a
v2144 = var144 (vs144 (vs144 vz144))

v3144 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm144 (snoc144 (snoc144 (snoc144 (snoc144 g a) B) C) D) a
v3144 = var144 (vs144 (vs144 (vs144 vz144)))

v4144 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm144 (snoc144 (snoc144 (snoc144 (snoc144 (snoc144 g a) B) C) D) E) a
v4144 = var144 (vs144 (vs144 (vs144 (vs144 vz144))))

test144 : {g:_}-> {a:_} -> Tm144 g (arr144 (arr144 a a) (arr144 a a))
test144  = lam144 (lam144 (app144 v1144 (app144 v1144 (app144 v1144 (app144 v1144 (app144 v1144 (app144 v1144 v0144)))))))
Ty145 : Type
Ty145 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty145 : Ty145
empty145 = \ _, empty, _ => empty

arr145 : Ty145 -> Ty145 -> Ty145
arr145 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con145 : Type
Con145 = (Con145 : Type)
 ->(nil  : Con145)
 ->(snoc : Con145 -> Ty145 -> Con145)
 -> Con145

nil145 : Con145
nil145 = \ con, nil145, snoc => nil145

snoc145 : Con145 -> Ty145 -> Con145
snoc145 = \ g, a, con, nil145, snoc145 => snoc145 (g con nil145 snoc145) a

Var145 : Con145 -> Ty145 -> Type
Var145 = \ g, a =>
    (Var145 : Con145 -> Ty145 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var145 (snoc145 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var145 g a -> Var145 (snoc145 g b) a)
 -> Var145 g a

vz145 : {g : _}-> {a : _} -> Var145 (snoc145 g a) a
vz145 = \ var, vz145, vs => vz145 _ _

vs145 : {g : _} -> {B : _} -> {a : _} -> Var145 g a -> Var145 (snoc145 g B) a
vs145 = \ x, var, vz145, vs145 => vs145 _ _ _ (x var vz145 vs145)

Tm145 : Con145 -> Ty145 -> Type
Tm145 = \ g, a =>
    (Tm145    : Con145 -> Ty145 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var145 g a -> Tm145 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm145 (snoc145 g a) B -> Tm145 g (arr145 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm145 g (arr145 a B) -> Tm145 g a -> Tm145 g B)
 -> Tm145 g a

var145 : {g : _} -> {a : _} -> Var145 g a -> Tm145 g a
var145 = \ x, tm, var145, lam, app => var145 _ _ x

lam145 : {g : _} -> {a : _} -> {B : _} -> Tm145 (snoc145 g a) B -> Tm145 g (arr145 a B)
lam145 = \ t, tm, var145, lam145, app => lam145 _ _ _ (t tm var145 lam145 app)

app145 : {g:_}->{a:_}->{B:_} -> Tm145 g (arr145 a B) -> Tm145 g a -> Tm145 g B
app145 = \ t, u, tm, var145, lam145, app145 => app145 _ _ _ (t tm var145 lam145 app145) (u tm var145 lam145 app145)

v0145 : {g:_}->{a:_} -> Tm145 (snoc145 g a) a
v0145 = var145 vz145

v1145 : {g:_}->{a:_}-> {B:_}-> Tm145 (snoc145 (snoc145 g a) B) a
v1145 = var145 (vs145 vz145)

v2145 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm145 (snoc145 (snoc145 (snoc145 g a) B) C) a
v2145 = var145 (vs145 (vs145 vz145))

v3145 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm145 (snoc145 (snoc145 (snoc145 (snoc145 g a) B) C) D) a
v3145 = var145 (vs145 (vs145 (vs145 vz145)))

v4145 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm145 (snoc145 (snoc145 (snoc145 (snoc145 (snoc145 g a) B) C) D) E) a
v4145 = var145 (vs145 (vs145 (vs145 (vs145 vz145))))

test145 : {g:_}-> {a:_} -> Tm145 g (arr145 (arr145 a a) (arr145 a a))
test145  = lam145 (lam145 (app145 v1145 (app145 v1145 (app145 v1145 (app145 v1145 (app145 v1145 (app145 v1145 v0145)))))))
Ty146 : Type
Ty146 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty146 : Ty146
empty146 = \ _, empty, _ => empty

arr146 : Ty146 -> Ty146 -> Ty146
arr146 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con146 : Type
Con146 = (Con146 : Type)
 ->(nil  : Con146)
 ->(snoc : Con146 -> Ty146 -> Con146)
 -> Con146

nil146 : Con146
nil146 = \ con, nil146, snoc => nil146

snoc146 : Con146 -> Ty146 -> Con146
snoc146 = \ g, a, con, nil146, snoc146 => snoc146 (g con nil146 snoc146) a

Var146 : Con146 -> Ty146 -> Type
Var146 = \ g, a =>
    (Var146 : Con146 -> Ty146 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var146 (snoc146 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var146 g a -> Var146 (snoc146 g b) a)
 -> Var146 g a

vz146 : {g : _}-> {a : _} -> Var146 (snoc146 g a) a
vz146 = \ var, vz146, vs => vz146 _ _

vs146 : {g : _} -> {B : _} -> {a : _} -> Var146 g a -> Var146 (snoc146 g B) a
vs146 = \ x, var, vz146, vs146 => vs146 _ _ _ (x var vz146 vs146)

Tm146 : Con146 -> Ty146 -> Type
Tm146 = \ g, a =>
    (Tm146    : Con146 -> Ty146 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var146 g a -> Tm146 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm146 (snoc146 g a) B -> Tm146 g (arr146 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm146 g (arr146 a B) -> Tm146 g a -> Tm146 g B)
 -> Tm146 g a

var146 : {g : _} -> {a : _} -> Var146 g a -> Tm146 g a
var146 = \ x, tm, var146, lam, app => var146 _ _ x

lam146 : {g : _} -> {a : _} -> {B : _} -> Tm146 (snoc146 g a) B -> Tm146 g (arr146 a B)
lam146 = \ t, tm, var146, lam146, app => lam146 _ _ _ (t tm var146 lam146 app)

app146 : {g:_}->{a:_}->{B:_} -> Tm146 g (arr146 a B) -> Tm146 g a -> Tm146 g B
app146 = \ t, u, tm, var146, lam146, app146 => app146 _ _ _ (t tm var146 lam146 app146) (u tm var146 lam146 app146)

v0146 : {g:_}->{a:_} -> Tm146 (snoc146 g a) a
v0146 = var146 vz146

v1146 : {g:_}->{a:_}-> {B:_}-> Tm146 (snoc146 (snoc146 g a) B) a
v1146 = var146 (vs146 vz146)

v2146 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm146 (snoc146 (snoc146 (snoc146 g a) B) C) a
v2146 = var146 (vs146 (vs146 vz146))

v3146 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm146 (snoc146 (snoc146 (snoc146 (snoc146 g a) B) C) D) a
v3146 = var146 (vs146 (vs146 (vs146 vz146)))

v4146 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm146 (snoc146 (snoc146 (snoc146 (snoc146 (snoc146 g a) B) C) D) E) a
v4146 = var146 (vs146 (vs146 (vs146 (vs146 vz146))))

test146 : {g:_}-> {a:_} -> Tm146 g (arr146 (arr146 a a) (arr146 a a))
test146  = lam146 (lam146 (app146 v1146 (app146 v1146 (app146 v1146 (app146 v1146 (app146 v1146 (app146 v1146 v0146)))))))
Ty147 : Type
Ty147 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty147 : Ty147
empty147 = \ _, empty, _ => empty

arr147 : Ty147 -> Ty147 -> Ty147
arr147 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con147 : Type
Con147 = (Con147 : Type)
 ->(nil  : Con147)
 ->(snoc : Con147 -> Ty147 -> Con147)
 -> Con147

nil147 : Con147
nil147 = \ con, nil147, snoc => nil147

snoc147 : Con147 -> Ty147 -> Con147
snoc147 = \ g, a, con, nil147, snoc147 => snoc147 (g con nil147 snoc147) a

Var147 : Con147 -> Ty147 -> Type
Var147 = \ g, a =>
    (Var147 : Con147 -> Ty147 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var147 (snoc147 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var147 g a -> Var147 (snoc147 g b) a)
 -> Var147 g a

vz147 : {g : _}-> {a : _} -> Var147 (snoc147 g a) a
vz147 = \ var, vz147, vs => vz147 _ _

vs147 : {g : _} -> {B : _} -> {a : _} -> Var147 g a -> Var147 (snoc147 g B) a
vs147 = \ x, var, vz147, vs147 => vs147 _ _ _ (x var vz147 vs147)

Tm147 : Con147 -> Ty147 -> Type
Tm147 = \ g, a =>
    (Tm147    : Con147 -> Ty147 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var147 g a -> Tm147 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm147 (snoc147 g a) B -> Tm147 g (arr147 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm147 g (arr147 a B) -> Tm147 g a -> Tm147 g B)
 -> Tm147 g a

var147 : {g : _} -> {a : _} -> Var147 g a -> Tm147 g a
var147 = \ x, tm, var147, lam, app => var147 _ _ x

lam147 : {g : _} -> {a : _} -> {B : _} -> Tm147 (snoc147 g a) B -> Tm147 g (arr147 a B)
lam147 = \ t, tm, var147, lam147, app => lam147 _ _ _ (t tm var147 lam147 app)

app147 : {g:_}->{a:_}->{B:_} -> Tm147 g (arr147 a B) -> Tm147 g a -> Tm147 g B
app147 = \ t, u, tm, var147, lam147, app147 => app147 _ _ _ (t tm var147 lam147 app147) (u tm var147 lam147 app147)

v0147 : {g:_}->{a:_} -> Tm147 (snoc147 g a) a
v0147 = var147 vz147

v1147 : {g:_}->{a:_}-> {B:_}-> Tm147 (snoc147 (snoc147 g a) B) a
v1147 = var147 (vs147 vz147)

v2147 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm147 (snoc147 (snoc147 (snoc147 g a) B) C) a
v2147 = var147 (vs147 (vs147 vz147))

v3147 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm147 (snoc147 (snoc147 (snoc147 (snoc147 g a) B) C) D) a
v3147 = var147 (vs147 (vs147 (vs147 vz147)))

v4147 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm147 (snoc147 (snoc147 (snoc147 (snoc147 (snoc147 g a) B) C) D) E) a
v4147 = var147 (vs147 (vs147 (vs147 (vs147 vz147))))

test147 : {g:_}-> {a:_} -> Tm147 g (arr147 (arr147 a a) (arr147 a a))
test147  = lam147 (lam147 (app147 v1147 (app147 v1147 (app147 v1147 (app147 v1147 (app147 v1147 (app147 v1147 v0147)))))))
Ty148 : Type
Ty148 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty148 : Ty148
empty148 = \ _, empty, _ => empty

arr148 : Ty148 -> Ty148 -> Ty148
arr148 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con148 : Type
Con148 = (Con148 : Type)
 ->(nil  : Con148)
 ->(snoc : Con148 -> Ty148 -> Con148)
 -> Con148

nil148 : Con148
nil148 = \ con, nil148, snoc => nil148

snoc148 : Con148 -> Ty148 -> Con148
snoc148 = \ g, a, con, nil148, snoc148 => snoc148 (g con nil148 snoc148) a

Var148 : Con148 -> Ty148 -> Type
Var148 = \ g, a =>
    (Var148 : Con148 -> Ty148 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var148 (snoc148 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var148 g a -> Var148 (snoc148 g b) a)
 -> Var148 g a

vz148 : {g : _}-> {a : _} -> Var148 (snoc148 g a) a
vz148 = \ var, vz148, vs => vz148 _ _

vs148 : {g : _} -> {B : _} -> {a : _} -> Var148 g a -> Var148 (snoc148 g B) a
vs148 = \ x, var, vz148, vs148 => vs148 _ _ _ (x var vz148 vs148)

Tm148 : Con148 -> Ty148 -> Type
Tm148 = \ g, a =>
    (Tm148    : Con148 -> Ty148 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var148 g a -> Tm148 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm148 (snoc148 g a) B -> Tm148 g (arr148 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm148 g (arr148 a B) -> Tm148 g a -> Tm148 g B)
 -> Tm148 g a

var148 : {g : _} -> {a : _} -> Var148 g a -> Tm148 g a
var148 = \ x, tm, var148, lam, app => var148 _ _ x

lam148 : {g : _} -> {a : _} -> {B : _} -> Tm148 (snoc148 g a) B -> Tm148 g (arr148 a B)
lam148 = \ t, tm, var148, lam148, app => lam148 _ _ _ (t tm var148 lam148 app)

app148 : {g:_}->{a:_}->{B:_} -> Tm148 g (arr148 a B) -> Tm148 g a -> Tm148 g B
app148 = \ t, u, tm, var148, lam148, app148 => app148 _ _ _ (t tm var148 lam148 app148) (u tm var148 lam148 app148)

v0148 : {g:_}->{a:_} -> Tm148 (snoc148 g a) a
v0148 = var148 vz148

v1148 : {g:_}->{a:_}-> {B:_}-> Tm148 (snoc148 (snoc148 g a) B) a
v1148 = var148 (vs148 vz148)

v2148 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm148 (snoc148 (snoc148 (snoc148 g a) B) C) a
v2148 = var148 (vs148 (vs148 vz148))

v3148 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm148 (snoc148 (snoc148 (snoc148 (snoc148 g a) B) C) D) a
v3148 = var148 (vs148 (vs148 (vs148 vz148)))

v4148 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm148 (snoc148 (snoc148 (snoc148 (snoc148 (snoc148 g a) B) C) D) E) a
v4148 = var148 (vs148 (vs148 (vs148 (vs148 vz148))))

test148 : {g:_}-> {a:_} -> Tm148 g (arr148 (arr148 a a) (arr148 a a))
test148  = lam148 (lam148 (app148 v1148 (app148 v1148 (app148 v1148 (app148 v1148 (app148 v1148 (app148 v1148 v0148)))))))
Ty149 : Type
Ty149 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty149 : Ty149
empty149 = \ _, empty, _ => empty

arr149 : Ty149 -> Ty149 -> Ty149
arr149 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con149 : Type
Con149 = (Con149 : Type)
 ->(nil  : Con149)
 ->(snoc : Con149 -> Ty149 -> Con149)
 -> Con149

nil149 : Con149
nil149 = \ con, nil149, snoc => nil149

snoc149 : Con149 -> Ty149 -> Con149
snoc149 = \ g, a, con, nil149, snoc149 => snoc149 (g con nil149 snoc149) a

Var149 : Con149 -> Ty149 -> Type
Var149 = \ g, a =>
    (Var149 : Con149 -> Ty149 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var149 (snoc149 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var149 g a -> Var149 (snoc149 g b) a)
 -> Var149 g a

vz149 : {g : _}-> {a : _} -> Var149 (snoc149 g a) a
vz149 = \ var, vz149, vs => vz149 _ _

vs149 : {g : _} -> {B : _} -> {a : _} -> Var149 g a -> Var149 (snoc149 g B) a
vs149 = \ x, var, vz149, vs149 => vs149 _ _ _ (x var vz149 vs149)

Tm149 : Con149 -> Ty149 -> Type
Tm149 = \ g, a =>
    (Tm149    : Con149 -> Ty149 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var149 g a -> Tm149 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm149 (snoc149 g a) B -> Tm149 g (arr149 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm149 g (arr149 a B) -> Tm149 g a -> Tm149 g B)
 -> Tm149 g a

var149 : {g : _} -> {a : _} -> Var149 g a -> Tm149 g a
var149 = \ x, tm, var149, lam, app => var149 _ _ x

lam149 : {g : _} -> {a : _} -> {B : _} -> Tm149 (snoc149 g a) B -> Tm149 g (arr149 a B)
lam149 = \ t, tm, var149, lam149, app => lam149 _ _ _ (t tm var149 lam149 app)

app149 : {g:_}->{a:_}->{B:_} -> Tm149 g (arr149 a B) -> Tm149 g a -> Tm149 g B
app149 = \ t, u, tm, var149, lam149, app149 => app149 _ _ _ (t tm var149 lam149 app149) (u tm var149 lam149 app149)

v0149 : {g:_}->{a:_} -> Tm149 (snoc149 g a) a
v0149 = var149 vz149

v1149 : {g:_}->{a:_}-> {B:_}-> Tm149 (snoc149 (snoc149 g a) B) a
v1149 = var149 (vs149 vz149)

v2149 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm149 (snoc149 (snoc149 (snoc149 g a) B) C) a
v2149 = var149 (vs149 (vs149 vz149))

v3149 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm149 (snoc149 (snoc149 (snoc149 (snoc149 g a) B) C) D) a
v3149 = var149 (vs149 (vs149 (vs149 vz149)))

v4149 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm149 (snoc149 (snoc149 (snoc149 (snoc149 (snoc149 g a) B) C) D) E) a
v4149 = var149 (vs149 (vs149 (vs149 (vs149 vz149))))

test149 : {g:_}-> {a:_} -> Tm149 g (arr149 (arr149 a a) (arr149 a a))
test149  = lam149 (lam149 (app149 v1149 (app149 v1149 (app149 v1149 (app149 v1149 (app149 v1149 (app149 v1149 v0149)))))))
Ty150 : Type
Ty150 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty150 : Ty150
empty150 = \ _, empty, _ => empty

arr150 : Ty150 -> Ty150 -> Ty150
arr150 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con150 : Type
Con150 = (Con150 : Type)
 ->(nil  : Con150)
 ->(snoc : Con150 -> Ty150 -> Con150)
 -> Con150

nil150 : Con150
nil150 = \ con, nil150, snoc => nil150

snoc150 : Con150 -> Ty150 -> Con150
snoc150 = \ g, a, con, nil150, snoc150 => snoc150 (g con nil150 snoc150) a

Var150 : Con150 -> Ty150 -> Type
Var150 = \ g, a =>
    (Var150 : Con150 -> Ty150 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var150 (snoc150 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var150 g a -> Var150 (snoc150 g b) a)
 -> Var150 g a

vz150 : {g : _}-> {a : _} -> Var150 (snoc150 g a) a
vz150 = \ var, vz150, vs => vz150 _ _

vs150 : {g : _} -> {B : _} -> {a : _} -> Var150 g a -> Var150 (snoc150 g B) a
vs150 = \ x, var, vz150, vs150 => vs150 _ _ _ (x var vz150 vs150)

Tm150 : Con150 -> Ty150 -> Type
Tm150 = \ g, a =>
    (Tm150    : Con150 -> Ty150 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var150 g a -> Tm150 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm150 (snoc150 g a) B -> Tm150 g (arr150 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm150 g (arr150 a B) -> Tm150 g a -> Tm150 g B)
 -> Tm150 g a

var150 : {g : _} -> {a : _} -> Var150 g a -> Tm150 g a
var150 = \ x, tm, var150, lam, app => var150 _ _ x

lam150 : {g : _} -> {a : _} -> {B : _} -> Tm150 (snoc150 g a) B -> Tm150 g (arr150 a B)
lam150 = \ t, tm, var150, lam150, app => lam150 _ _ _ (t tm var150 lam150 app)

app150 : {g:_}->{a:_}->{B:_} -> Tm150 g (arr150 a B) -> Tm150 g a -> Tm150 g B
app150 = \ t, u, tm, var150, lam150, app150 => app150 _ _ _ (t tm var150 lam150 app150) (u tm var150 lam150 app150)

v0150 : {g:_}->{a:_} -> Tm150 (snoc150 g a) a
v0150 = var150 vz150

v1150 : {g:_}->{a:_}-> {B:_}-> Tm150 (snoc150 (snoc150 g a) B) a
v1150 = var150 (vs150 vz150)

v2150 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm150 (snoc150 (snoc150 (snoc150 g a) B) C) a
v2150 = var150 (vs150 (vs150 vz150))

v3150 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm150 (snoc150 (snoc150 (snoc150 (snoc150 g a) B) C) D) a
v3150 = var150 (vs150 (vs150 (vs150 vz150)))

v4150 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm150 (snoc150 (snoc150 (snoc150 (snoc150 (snoc150 g a) B) C) D) E) a
v4150 = var150 (vs150 (vs150 (vs150 (vs150 vz150))))

test150 : {g:_}-> {a:_} -> Tm150 g (arr150 (arr150 a a) (arr150 a a))
test150  = lam150 (lam150 (app150 v1150 (app150 v1150 (app150 v1150 (app150 v1150 (app150 v1150 (app150 v1150 v0150)))))))
Ty151 : Type
Ty151 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty151 : Ty151
empty151 = \ _, empty, _ => empty

arr151 : Ty151 -> Ty151 -> Ty151
arr151 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con151 : Type
Con151 = (Con151 : Type)
 ->(nil  : Con151)
 ->(snoc : Con151 -> Ty151 -> Con151)
 -> Con151

nil151 : Con151
nil151 = \ con, nil151, snoc => nil151

snoc151 : Con151 -> Ty151 -> Con151
snoc151 = \ g, a, con, nil151, snoc151 => snoc151 (g con nil151 snoc151) a

Var151 : Con151 -> Ty151 -> Type
Var151 = \ g, a =>
    (Var151 : Con151 -> Ty151 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var151 (snoc151 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var151 g a -> Var151 (snoc151 g b) a)
 -> Var151 g a

vz151 : {g : _}-> {a : _} -> Var151 (snoc151 g a) a
vz151 = \ var, vz151, vs => vz151 _ _

vs151 : {g : _} -> {B : _} -> {a : _} -> Var151 g a -> Var151 (snoc151 g B) a
vs151 = \ x, var, vz151, vs151 => vs151 _ _ _ (x var vz151 vs151)

Tm151 : Con151 -> Ty151 -> Type
Tm151 = \ g, a =>
    (Tm151    : Con151 -> Ty151 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var151 g a -> Tm151 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm151 (snoc151 g a) B -> Tm151 g (arr151 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm151 g (arr151 a B) -> Tm151 g a -> Tm151 g B)
 -> Tm151 g a

var151 : {g : _} -> {a : _} -> Var151 g a -> Tm151 g a
var151 = \ x, tm, var151, lam, app => var151 _ _ x

lam151 : {g : _} -> {a : _} -> {B : _} -> Tm151 (snoc151 g a) B -> Tm151 g (arr151 a B)
lam151 = \ t, tm, var151, lam151, app => lam151 _ _ _ (t tm var151 lam151 app)

app151 : {g:_}->{a:_}->{B:_} -> Tm151 g (arr151 a B) -> Tm151 g a -> Tm151 g B
app151 = \ t, u, tm, var151, lam151, app151 => app151 _ _ _ (t tm var151 lam151 app151) (u tm var151 lam151 app151)

v0151 : {g:_}->{a:_} -> Tm151 (snoc151 g a) a
v0151 = var151 vz151

v1151 : {g:_}->{a:_}-> {B:_}-> Tm151 (snoc151 (snoc151 g a) B) a
v1151 = var151 (vs151 vz151)

v2151 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm151 (snoc151 (snoc151 (snoc151 g a) B) C) a
v2151 = var151 (vs151 (vs151 vz151))

v3151 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm151 (snoc151 (snoc151 (snoc151 (snoc151 g a) B) C) D) a
v3151 = var151 (vs151 (vs151 (vs151 vz151)))

v4151 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm151 (snoc151 (snoc151 (snoc151 (snoc151 (snoc151 g a) B) C) D) E) a
v4151 = var151 (vs151 (vs151 (vs151 (vs151 vz151))))

test151 : {g:_}-> {a:_} -> Tm151 g (arr151 (arr151 a a) (arr151 a a))
test151  = lam151 (lam151 (app151 v1151 (app151 v1151 (app151 v1151 (app151 v1151 (app151 v1151 (app151 v1151 v0151)))))))
Ty152 : Type
Ty152 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty152 : Ty152
empty152 = \ _, empty, _ => empty

arr152 : Ty152 -> Ty152 -> Ty152
arr152 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con152 : Type
Con152 = (Con152 : Type)
 ->(nil  : Con152)
 ->(snoc : Con152 -> Ty152 -> Con152)
 -> Con152

nil152 : Con152
nil152 = \ con, nil152, snoc => nil152

snoc152 : Con152 -> Ty152 -> Con152
snoc152 = \ g, a, con, nil152, snoc152 => snoc152 (g con nil152 snoc152) a

Var152 : Con152 -> Ty152 -> Type
Var152 = \ g, a =>
    (Var152 : Con152 -> Ty152 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var152 (snoc152 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var152 g a -> Var152 (snoc152 g b) a)
 -> Var152 g a

vz152 : {g : _}-> {a : _} -> Var152 (snoc152 g a) a
vz152 = \ var, vz152, vs => vz152 _ _

vs152 : {g : _} -> {B : _} -> {a : _} -> Var152 g a -> Var152 (snoc152 g B) a
vs152 = \ x, var, vz152, vs152 => vs152 _ _ _ (x var vz152 vs152)

Tm152 : Con152 -> Ty152 -> Type
Tm152 = \ g, a =>
    (Tm152    : Con152 -> Ty152 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var152 g a -> Tm152 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm152 (snoc152 g a) B -> Tm152 g (arr152 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm152 g (arr152 a B) -> Tm152 g a -> Tm152 g B)
 -> Tm152 g a

var152 : {g : _} -> {a : _} -> Var152 g a -> Tm152 g a
var152 = \ x, tm, var152, lam, app => var152 _ _ x

lam152 : {g : _} -> {a : _} -> {B : _} -> Tm152 (snoc152 g a) B -> Tm152 g (arr152 a B)
lam152 = \ t, tm, var152, lam152, app => lam152 _ _ _ (t tm var152 lam152 app)

app152 : {g:_}->{a:_}->{B:_} -> Tm152 g (arr152 a B) -> Tm152 g a -> Tm152 g B
app152 = \ t, u, tm, var152, lam152, app152 => app152 _ _ _ (t tm var152 lam152 app152) (u tm var152 lam152 app152)

v0152 : {g:_}->{a:_} -> Tm152 (snoc152 g a) a
v0152 = var152 vz152

v1152 : {g:_}->{a:_}-> {B:_}-> Tm152 (snoc152 (snoc152 g a) B) a
v1152 = var152 (vs152 vz152)

v2152 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm152 (snoc152 (snoc152 (snoc152 g a) B) C) a
v2152 = var152 (vs152 (vs152 vz152))

v3152 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm152 (snoc152 (snoc152 (snoc152 (snoc152 g a) B) C) D) a
v3152 = var152 (vs152 (vs152 (vs152 vz152)))

v4152 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm152 (snoc152 (snoc152 (snoc152 (snoc152 (snoc152 g a) B) C) D) E) a
v4152 = var152 (vs152 (vs152 (vs152 (vs152 vz152))))

test152 : {g:_}-> {a:_} -> Tm152 g (arr152 (arr152 a a) (arr152 a a))
test152  = lam152 (lam152 (app152 v1152 (app152 v1152 (app152 v1152 (app152 v1152 (app152 v1152 (app152 v1152 v0152)))))))
Ty153 : Type
Ty153 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty153 : Ty153
empty153 = \ _, empty, _ => empty

arr153 : Ty153 -> Ty153 -> Ty153
arr153 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con153 : Type
Con153 = (Con153 : Type)
 ->(nil  : Con153)
 ->(snoc : Con153 -> Ty153 -> Con153)
 -> Con153

nil153 : Con153
nil153 = \ con, nil153, snoc => nil153

snoc153 : Con153 -> Ty153 -> Con153
snoc153 = \ g, a, con, nil153, snoc153 => snoc153 (g con nil153 snoc153) a

Var153 : Con153 -> Ty153 -> Type
Var153 = \ g, a =>
    (Var153 : Con153 -> Ty153 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var153 (snoc153 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var153 g a -> Var153 (snoc153 g b) a)
 -> Var153 g a

vz153 : {g : _}-> {a : _} -> Var153 (snoc153 g a) a
vz153 = \ var, vz153, vs => vz153 _ _

vs153 : {g : _} -> {B : _} -> {a : _} -> Var153 g a -> Var153 (snoc153 g B) a
vs153 = \ x, var, vz153, vs153 => vs153 _ _ _ (x var vz153 vs153)

Tm153 : Con153 -> Ty153 -> Type
Tm153 = \ g, a =>
    (Tm153    : Con153 -> Ty153 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var153 g a -> Tm153 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm153 (snoc153 g a) B -> Tm153 g (arr153 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm153 g (arr153 a B) -> Tm153 g a -> Tm153 g B)
 -> Tm153 g a

var153 : {g : _} -> {a : _} -> Var153 g a -> Tm153 g a
var153 = \ x, tm, var153, lam, app => var153 _ _ x

lam153 : {g : _} -> {a : _} -> {B : _} -> Tm153 (snoc153 g a) B -> Tm153 g (arr153 a B)
lam153 = \ t, tm, var153, lam153, app => lam153 _ _ _ (t tm var153 lam153 app)

app153 : {g:_}->{a:_}->{B:_} -> Tm153 g (arr153 a B) -> Tm153 g a -> Tm153 g B
app153 = \ t, u, tm, var153, lam153, app153 => app153 _ _ _ (t tm var153 lam153 app153) (u tm var153 lam153 app153)

v0153 : {g:_}->{a:_} -> Tm153 (snoc153 g a) a
v0153 = var153 vz153

v1153 : {g:_}->{a:_}-> {B:_}-> Tm153 (snoc153 (snoc153 g a) B) a
v1153 = var153 (vs153 vz153)

v2153 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm153 (snoc153 (snoc153 (snoc153 g a) B) C) a
v2153 = var153 (vs153 (vs153 vz153))

v3153 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm153 (snoc153 (snoc153 (snoc153 (snoc153 g a) B) C) D) a
v3153 = var153 (vs153 (vs153 (vs153 vz153)))

v4153 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm153 (snoc153 (snoc153 (snoc153 (snoc153 (snoc153 g a) B) C) D) E) a
v4153 = var153 (vs153 (vs153 (vs153 (vs153 vz153))))

test153 : {g:_}-> {a:_} -> Tm153 g (arr153 (arr153 a a) (arr153 a a))
test153  = lam153 (lam153 (app153 v1153 (app153 v1153 (app153 v1153 (app153 v1153 (app153 v1153 (app153 v1153 v0153)))))))
Ty154 : Type
Ty154 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty154 : Ty154
empty154 = \ _, empty, _ => empty

arr154 : Ty154 -> Ty154 -> Ty154
arr154 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con154 : Type
Con154 = (Con154 : Type)
 ->(nil  : Con154)
 ->(snoc : Con154 -> Ty154 -> Con154)
 -> Con154

nil154 : Con154
nil154 = \ con, nil154, snoc => nil154

snoc154 : Con154 -> Ty154 -> Con154
snoc154 = \ g, a, con, nil154, snoc154 => snoc154 (g con nil154 snoc154) a

Var154 : Con154 -> Ty154 -> Type
Var154 = \ g, a =>
    (Var154 : Con154 -> Ty154 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var154 (snoc154 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var154 g a -> Var154 (snoc154 g b) a)
 -> Var154 g a

vz154 : {g : _}-> {a : _} -> Var154 (snoc154 g a) a
vz154 = \ var, vz154, vs => vz154 _ _

vs154 : {g : _} -> {B : _} -> {a : _} -> Var154 g a -> Var154 (snoc154 g B) a
vs154 = \ x, var, vz154, vs154 => vs154 _ _ _ (x var vz154 vs154)

Tm154 : Con154 -> Ty154 -> Type
Tm154 = \ g, a =>
    (Tm154    : Con154 -> Ty154 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var154 g a -> Tm154 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm154 (snoc154 g a) B -> Tm154 g (arr154 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm154 g (arr154 a B) -> Tm154 g a -> Tm154 g B)
 -> Tm154 g a

var154 : {g : _} -> {a : _} -> Var154 g a -> Tm154 g a
var154 = \ x, tm, var154, lam, app => var154 _ _ x

lam154 : {g : _} -> {a : _} -> {B : _} -> Tm154 (snoc154 g a) B -> Tm154 g (arr154 a B)
lam154 = \ t, tm, var154, lam154, app => lam154 _ _ _ (t tm var154 lam154 app)

app154 : {g:_}->{a:_}->{B:_} -> Tm154 g (arr154 a B) -> Tm154 g a -> Tm154 g B
app154 = \ t, u, tm, var154, lam154, app154 => app154 _ _ _ (t tm var154 lam154 app154) (u tm var154 lam154 app154)

v0154 : {g:_}->{a:_} -> Tm154 (snoc154 g a) a
v0154 = var154 vz154

v1154 : {g:_}->{a:_}-> {B:_}-> Tm154 (snoc154 (snoc154 g a) B) a
v1154 = var154 (vs154 vz154)

v2154 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm154 (snoc154 (snoc154 (snoc154 g a) B) C) a
v2154 = var154 (vs154 (vs154 vz154))

v3154 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm154 (snoc154 (snoc154 (snoc154 (snoc154 g a) B) C) D) a
v3154 = var154 (vs154 (vs154 (vs154 vz154)))

v4154 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm154 (snoc154 (snoc154 (snoc154 (snoc154 (snoc154 g a) B) C) D) E) a
v4154 = var154 (vs154 (vs154 (vs154 (vs154 vz154))))

test154 : {g:_}-> {a:_} -> Tm154 g (arr154 (arr154 a a) (arr154 a a))
test154  = lam154 (lam154 (app154 v1154 (app154 v1154 (app154 v1154 (app154 v1154 (app154 v1154 (app154 v1154 v0154)))))))
Ty155 : Type
Ty155 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty155 : Ty155
empty155 = \ _, empty, _ => empty

arr155 : Ty155 -> Ty155 -> Ty155
arr155 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con155 : Type
Con155 = (Con155 : Type)
 ->(nil  : Con155)
 ->(snoc : Con155 -> Ty155 -> Con155)
 -> Con155

nil155 : Con155
nil155 = \ con, nil155, snoc => nil155

snoc155 : Con155 -> Ty155 -> Con155
snoc155 = \ g, a, con, nil155, snoc155 => snoc155 (g con nil155 snoc155) a

Var155 : Con155 -> Ty155 -> Type
Var155 = \ g, a =>
    (Var155 : Con155 -> Ty155 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var155 (snoc155 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var155 g a -> Var155 (snoc155 g b) a)
 -> Var155 g a

vz155 : {g : _}-> {a : _} -> Var155 (snoc155 g a) a
vz155 = \ var, vz155, vs => vz155 _ _

vs155 : {g : _} -> {B : _} -> {a : _} -> Var155 g a -> Var155 (snoc155 g B) a
vs155 = \ x, var, vz155, vs155 => vs155 _ _ _ (x var vz155 vs155)

Tm155 : Con155 -> Ty155 -> Type
Tm155 = \ g, a =>
    (Tm155    : Con155 -> Ty155 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var155 g a -> Tm155 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm155 (snoc155 g a) B -> Tm155 g (arr155 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm155 g (arr155 a B) -> Tm155 g a -> Tm155 g B)
 -> Tm155 g a

var155 : {g : _} -> {a : _} -> Var155 g a -> Tm155 g a
var155 = \ x, tm, var155, lam, app => var155 _ _ x

lam155 : {g : _} -> {a : _} -> {B : _} -> Tm155 (snoc155 g a) B -> Tm155 g (arr155 a B)
lam155 = \ t, tm, var155, lam155, app => lam155 _ _ _ (t tm var155 lam155 app)

app155 : {g:_}->{a:_}->{B:_} -> Tm155 g (arr155 a B) -> Tm155 g a -> Tm155 g B
app155 = \ t, u, tm, var155, lam155, app155 => app155 _ _ _ (t tm var155 lam155 app155) (u tm var155 lam155 app155)

v0155 : {g:_}->{a:_} -> Tm155 (snoc155 g a) a
v0155 = var155 vz155

v1155 : {g:_}->{a:_}-> {B:_}-> Tm155 (snoc155 (snoc155 g a) B) a
v1155 = var155 (vs155 vz155)

v2155 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm155 (snoc155 (snoc155 (snoc155 g a) B) C) a
v2155 = var155 (vs155 (vs155 vz155))

v3155 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm155 (snoc155 (snoc155 (snoc155 (snoc155 g a) B) C) D) a
v3155 = var155 (vs155 (vs155 (vs155 vz155)))

v4155 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm155 (snoc155 (snoc155 (snoc155 (snoc155 (snoc155 g a) B) C) D) E) a
v4155 = var155 (vs155 (vs155 (vs155 (vs155 vz155))))

test155 : {g:_}-> {a:_} -> Tm155 g (arr155 (arr155 a a) (arr155 a a))
test155  = lam155 (lam155 (app155 v1155 (app155 v1155 (app155 v1155 (app155 v1155 (app155 v1155 (app155 v1155 v0155)))))))
Ty156 : Type
Ty156 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty156 : Ty156
empty156 = \ _, empty, _ => empty

arr156 : Ty156 -> Ty156 -> Ty156
arr156 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con156 : Type
Con156 = (Con156 : Type)
 ->(nil  : Con156)
 ->(snoc : Con156 -> Ty156 -> Con156)
 -> Con156

nil156 : Con156
nil156 = \ con, nil156, snoc => nil156

snoc156 : Con156 -> Ty156 -> Con156
snoc156 = \ g, a, con, nil156, snoc156 => snoc156 (g con nil156 snoc156) a

Var156 : Con156 -> Ty156 -> Type
Var156 = \ g, a =>
    (Var156 : Con156 -> Ty156 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var156 (snoc156 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var156 g a -> Var156 (snoc156 g b) a)
 -> Var156 g a

vz156 : {g : _}-> {a : _} -> Var156 (snoc156 g a) a
vz156 = \ var, vz156, vs => vz156 _ _

vs156 : {g : _} -> {B : _} -> {a : _} -> Var156 g a -> Var156 (snoc156 g B) a
vs156 = \ x, var, vz156, vs156 => vs156 _ _ _ (x var vz156 vs156)

Tm156 : Con156 -> Ty156 -> Type
Tm156 = \ g, a =>
    (Tm156    : Con156 -> Ty156 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var156 g a -> Tm156 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm156 (snoc156 g a) B -> Tm156 g (arr156 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm156 g (arr156 a B) -> Tm156 g a -> Tm156 g B)
 -> Tm156 g a

var156 : {g : _} -> {a : _} -> Var156 g a -> Tm156 g a
var156 = \ x, tm, var156, lam, app => var156 _ _ x

lam156 : {g : _} -> {a : _} -> {B : _} -> Tm156 (snoc156 g a) B -> Tm156 g (arr156 a B)
lam156 = \ t, tm, var156, lam156, app => lam156 _ _ _ (t tm var156 lam156 app)

app156 : {g:_}->{a:_}->{B:_} -> Tm156 g (arr156 a B) -> Tm156 g a -> Tm156 g B
app156 = \ t, u, tm, var156, lam156, app156 => app156 _ _ _ (t tm var156 lam156 app156) (u tm var156 lam156 app156)

v0156 : {g:_}->{a:_} -> Tm156 (snoc156 g a) a
v0156 = var156 vz156

v1156 : {g:_}->{a:_}-> {B:_}-> Tm156 (snoc156 (snoc156 g a) B) a
v1156 = var156 (vs156 vz156)

v2156 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm156 (snoc156 (snoc156 (snoc156 g a) B) C) a
v2156 = var156 (vs156 (vs156 vz156))

v3156 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm156 (snoc156 (snoc156 (snoc156 (snoc156 g a) B) C) D) a
v3156 = var156 (vs156 (vs156 (vs156 vz156)))

v4156 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm156 (snoc156 (snoc156 (snoc156 (snoc156 (snoc156 g a) B) C) D) E) a
v4156 = var156 (vs156 (vs156 (vs156 (vs156 vz156))))

test156 : {g:_}-> {a:_} -> Tm156 g (arr156 (arr156 a a) (arr156 a a))
test156  = lam156 (lam156 (app156 v1156 (app156 v1156 (app156 v1156 (app156 v1156 (app156 v1156 (app156 v1156 v0156)))))))
Ty157 : Type
Ty157 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty157 : Ty157
empty157 = \ _, empty, _ => empty

arr157 : Ty157 -> Ty157 -> Ty157
arr157 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con157 : Type
Con157 = (Con157 : Type)
 ->(nil  : Con157)
 ->(snoc : Con157 -> Ty157 -> Con157)
 -> Con157

nil157 : Con157
nil157 = \ con, nil157, snoc => nil157

snoc157 : Con157 -> Ty157 -> Con157
snoc157 = \ g, a, con, nil157, snoc157 => snoc157 (g con nil157 snoc157) a

Var157 : Con157 -> Ty157 -> Type
Var157 = \ g, a =>
    (Var157 : Con157 -> Ty157 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var157 (snoc157 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var157 g a -> Var157 (snoc157 g b) a)
 -> Var157 g a

vz157 : {g : _}-> {a : _} -> Var157 (snoc157 g a) a
vz157 = \ var, vz157, vs => vz157 _ _

vs157 : {g : _} -> {B : _} -> {a : _} -> Var157 g a -> Var157 (snoc157 g B) a
vs157 = \ x, var, vz157, vs157 => vs157 _ _ _ (x var vz157 vs157)

Tm157 : Con157 -> Ty157 -> Type
Tm157 = \ g, a =>
    (Tm157    : Con157 -> Ty157 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var157 g a -> Tm157 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm157 (snoc157 g a) B -> Tm157 g (arr157 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm157 g (arr157 a B) -> Tm157 g a -> Tm157 g B)
 -> Tm157 g a

var157 : {g : _} -> {a : _} -> Var157 g a -> Tm157 g a
var157 = \ x, tm, var157, lam, app => var157 _ _ x

lam157 : {g : _} -> {a : _} -> {B : _} -> Tm157 (snoc157 g a) B -> Tm157 g (arr157 a B)
lam157 = \ t, tm, var157, lam157, app => lam157 _ _ _ (t tm var157 lam157 app)

app157 : {g:_}->{a:_}->{B:_} -> Tm157 g (arr157 a B) -> Tm157 g a -> Tm157 g B
app157 = \ t, u, tm, var157, lam157, app157 => app157 _ _ _ (t tm var157 lam157 app157) (u tm var157 lam157 app157)

v0157 : {g:_}->{a:_} -> Tm157 (snoc157 g a) a
v0157 = var157 vz157

v1157 : {g:_}->{a:_}-> {B:_}-> Tm157 (snoc157 (snoc157 g a) B) a
v1157 = var157 (vs157 vz157)

v2157 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm157 (snoc157 (snoc157 (snoc157 g a) B) C) a
v2157 = var157 (vs157 (vs157 vz157))

v3157 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm157 (snoc157 (snoc157 (snoc157 (snoc157 g a) B) C) D) a
v3157 = var157 (vs157 (vs157 (vs157 vz157)))

v4157 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm157 (snoc157 (snoc157 (snoc157 (snoc157 (snoc157 g a) B) C) D) E) a
v4157 = var157 (vs157 (vs157 (vs157 (vs157 vz157))))

test157 : {g:_}-> {a:_} -> Tm157 g (arr157 (arr157 a a) (arr157 a a))
test157  = lam157 (lam157 (app157 v1157 (app157 v1157 (app157 v1157 (app157 v1157 (app157 v1157 (app157 v1157 v0157)))))))
Ty158 : Type
Ty158 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty158 : Ty158
empty158 = \ _, empty, _ => empty

arr158 : Ty158 -> Ty158 -> Ty158
arr158 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con158 : Type
Con158 = (Con158 : Type)
 ->(nil  : Con158)
 ->(snoc : Con158 -> Ty158 -> Con158)
 -> Con158

nil158 : Con158
nil158 = \ con, nil158, snoc => nil158

snoc158 : Con158 -> Ty158 -> Con158
snoc158 = \ g, a, con, nil158, snoc158 => snoc158 (g con nil158 snoc158) a

Var158 : Con158 -> Ty158 -> Type
Var158 = \ g, a =>
    (Var158 : Con158 -> Ty158 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var158 (snoc158 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var158 g a -> Var158 (snoc158 g b) a)
 -> Var158 g a

vz158 : {g : _}-> {a : _} -> Var158 (snoc158 g a) a
vz158 = \ var, vz158, vs => vz158 _ _

vs158 : {g : _} -> {B : _} -> {a : _} -> Var158 g a -> Var158 (snoc158 g B) a
vs158 = \ x, var, vz158, vs158 => vs158 _ _ _ (x var vz158 vs158)

Tm158 : Con158 -> Ty158 -> Type
Tm158 = \ g, a =>
    (Tm158    : Con158 -> Ty158 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var158 g a -> Tm158 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm158 (snoc158 g a) B -> Tm158 g (arr158 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm158 g (arr158 a B) -> Tm158 g a -> Tm158 g B)
 -> Tm158 g a

var158 : {g : _} -> {a : _} -> Var158 g a -> Tm158 g a
var158 = \ x, tm, var158, lam, app => var158 _ _ x

lam158 : {g : _} -> {a : _} -> {B : _} -> Tm158 (snoc158 g a) B -> Tm158 g (arr158 a B)
lam158 = \ t, tm, var158, lam158, app => lam158 _ _ _ (t tm var158 lam158 app)

app158 : {g:_}->{a:_}->{B:_} -> Tm158 g (arr158 a B) -> Tm158 g a -> Tm158 g B
app158 = \ t, u, tm, var158, lam158, app158 => app158 _ _ _ (t tm var158 lam158 app158) (u tm var158 lam158 app158)

v0158 : {g:_}->{a:_} -> Tm158 (snoc158 g a) a
v0158 = var158 vz158

v1158 : {g:_}->{a:_}-> {B:_}-> Tm158 (snoc158 (snoc158 g a) B) a
v1158 = var158 (vs158 vz158)

v2158 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm158 (snoc158 (snoc158 (snoc158 g a) B) C) a
v2158 = var158 (vs158 (vs158 vz158))

v3158 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm158 (snoc158 (snoc158 (snoc158 (snoc158 g a) B) C) D) a
v3158 = var158 (vs158 (vs158 (vs158 vz158)))

v4158 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm158 (snoc158 (snoc158 (snoc158 (snoc158 (snoc158 g a) B) C) D) E) a
v4158 = var158 (vs158 (vs158 (vs158 (vs158 vz158))))

test158 : {g:_}-> {a:_} -> Tm158 g (arr158 (arr158 a a) (arr158 a a))
test158  = lam158 (lam158 (app158 v1158 (app158 v1158 (app158 v1158 (app158 v1158 (app158 v1158 (app158 v1158 v0158)))))))
Ty159 : Type
Ty159 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty159 : Ty159
empty159 = \ _, empty, _ => empty

arr159 : Ty159 -> Ty159 -> Ty159
arr159 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con159 : Type
Con159 = (Con159 : Type)
 ->(nil  : Con159)
 ->(snoc : Con159 -> Ty159 -> Con159)
 -> Con159

nil159 : Con159
nil159 = \ con, nil159, snoc => nil159

snoc159 : Con159 -> Ty159 -> Con159
snoc159 = \ g, a, con, nil159, snoc159 => snoc159 (g con nil159 snoc159) a

Var159 : Con159 -> Ty159 -> Type
Var159 = \ g, a =>
    (Var159 : Con159 -> Ty159 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var159 (snoc159 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var159 g a -> Var159 (snoc159 g b) a)
 -> Var159 g a

vz159 : {g : _}-> {a : _} -> Var159 (snoc159 g a) a
vz159 = \ var, vz159, vs => vz159 _ _

vs159 : {g : _} -> {B : _} -> {a : _} -> Var159 g a -> Var159 (snoc159 g B) a
vs159 = \ x, var, vz159, vs159 => vs159 _ _ _ (x var vz159 vs159)

Tm159 : Con159 -> Ty159 -> Type
Tm159 = \ g, a =>
    (Tm159    : Con159 -> Ty159 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var159 g a -> Tm159 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm159 (snoc159 g a) B -> Tm159 g (arr159 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm159 g (arr159 a B) -> Tm159 g a -> Tm159 g B)
 -> Tm159 g a

var159 : {g : _} -> {a : _} -> Var159 g a -> Tm159 g a
var159 = \ x, tm, var159, lam, app => var159 _ _ x

lam159 : {g : _} -> {a : _} -> {B : _} -> Tm159 (snoc159 g a) B -> Tm159 g (arr159 a B)
lam159 = \ t, tm, var159, lam159, app => lam159 _ _ _ (t tm var159 lam159 app)

app159 : {g:_}->{a:_}->{B:_} -> Tm159 g (arr159 a B) -> Tm159 g a -> Tm159 g B
app159 = \ t, u, tm, var159, lam159, app159 => app159 _ _ _ (t tm var159 lam159 app159) (u tm var159 lam159 app159)

v0159 : {g:_}->{a:_} -> Tm159 (snoc159 g a) a
v0159 = var159 vz159

v1159 : {g:_}->{a:_}-> {B:_}-> Tm159 (snoc159 (snoc159 g a) B) a
v1159 = var159 (vs159 vz159)

v2159 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm159 (snoc159 (snoc159 (snoc159 g a) B) C) a
v2159 = var159 (vs159 (vs159 vz159))

v3159 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm159 (snoc159 (snoc159 (snoc159 (snoc159 g a) B) C) D) a
v3159 = var159 (vs159 (vs159 (vs159 vz159)))

v4159 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm159 (snoc159 (snoc159 (snoc159 (snoc159 (snoc159 g a) B) C) D) E) a
v4159 = var159 (vs159 (vs159 (vs159 (vs159 vz159))))

test159 : {g:_}-> {a:_} -> Tm159 g (arr159 (arr159 a a) (arr159 a a))
test159  = lam159 (lam159 (app159 v1159 (app159 v1159 (app159 v1159 (app159 v1159 (app159 v1159 (app159 v1159 v0159)))))))
Ty160 : Type
Ty160 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty160 : Ty160
empty160 = \ _, empty, _ => empty

arr160 : Ty160 -> Ty160 -> Ty160
arr160 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con160 : Type
Con160 = (Con160 : Type)
 ->(nil  : Con160)
 ->(snoc : Con160 -> Ty160 -> Con160)
 -> Con160

nil160 : Con160
nil160 = \ con, nil160, snoc => nil160

snoc160 : Con160 -> Ty160 -> Con160
snoc160 = \ g, a, con, nil160, snoc160 => snoc160 (g con nil160 snoc160) a

Var160 : Con160 -> Ty160 -> Type
Var160 = \ g, a =>
    (Var160 : Con160 -> Ty160 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var160 (snoc160 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var160 g a -> Var160 (snoc160 g b) a)
 -> Var160 g a

vz160 : {g : _}-> {a : _} -> Var160 (snoc160 g a) a
vz160 = \ var, vz160, vs => vz160 _ _

vs160 : {g : _} -> {B : _} -> {a : _} -> Var160 g a -> Var160 (snoc160 g B) a
vs160 = \ x, var, vz160, vs160 => vs160 _ _ _ (x var vz160 vs160)

Tm160 : Con160 -> Ty160 -> Type
Tm160 = \ g, a =>
    (Tm160    : Con160 -> Ty160 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var160 g a -> Tm160 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm160 (snoc160 g a) B -> Tm160 g (arr160 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm160 g (arr160 a B) -> Tm160 g a -> Tm160 g B)
 -> Tm160 g a

var160 : {g : _} -> {a : _} -> Var160 g a -> Tm160 g a
var160 = \ x, tm, var160, lam, app => var160 _ _ x

lam160 : {g : _} -> {a : _} -> {B : _} -> Tm160 (snoc160 g a) B -> Tm160 g (arr160 a B)
lam160 = \ t, tm, var160, lam160, app => lam160 _ _ _ (t tm var160 lam160 app)

app160 : {g:_}->{a:_}->{B:_} -> Tm160 g (arr160 a B) -> Tm160 g a -> Tm160 g B
app160 = \ t, u, tm, var160, lam160, app160 => app160 _ _ _ (t tm var160 lam160 app160) (u tm var160 lam160 app160)

v0160 : {g:_}->{a:_} -> Tm160 (snoc160 g a) a
v0160 = var160 vz160

v1160 : {g:_}->{a:_}-> {B:_}-> Tm160 (snoc160 (snoc160 g a) B) a
v1160 = var160 (vs160 vz160)

v2160 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm160 (snoc160 (snoc160 (snoc160 g a) B) C) a
v2160 = var160 (vs160 (vs160 vz160))

v3160 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm160 (snoc160 (snoc160 (snoc160 (snoc160 g a) B) C) D) a
v3160 = var160 (vs160 (vs160 (vs160 vz160)))

v4160 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm160 (snoc160 (snoc160 (snoc160 (snoc160 (snoc160 g a) B) C) D) E) a
v4160 = var160 (vs160 (vs160 (vs160 (vs160 vz160))))

test160 : {g:_}-> {a:_} -> Tm160 g (arr160 (arr160 a a) (arr160 a a))
test160  = lam160 (lam160 (app160 v1160 (app160 v1160 (app160 v1160 (app160 v1160 (app160 v1160 (app160 v1160 v0160)))))))
Ty161 : Type
Ty161 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty161 : Ty161
empty161 = \ _, empty, _ => empty

arr161 : Ty161 -> Ty161 -> Ty161
arr161 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con161 : Type
Con161 = (Con161 : Type)
 ->(nil  : Con161)
 ->(snoc : Con161 -> Ty161 -> Con161)
 -> Con161

nil161 : Con161
nil161 = \ con, nil161, snoc => nil161

snoc161 : Con161 -> Ty161 -> Con161
snoc161 = \ g, a, con, nil161, snoc161 => snoc161 (g con nil161 snoc161) a

Var161 : Con161 -> Ty161 -> Type
Var161 = \ g, a =>
    (Var161 : Con161 -> Ty161 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var161 (snoc161 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var161 g a -> Var161 (snoc161 g b) a)
 -> Var161 g a

vz161 : {g : _}-> {a : _} -> Var161 (snoc161 g a) a
vz161 = \ var, vz161, vs => vz161 _ _

vs161 : {g : _} -> {B : _} -> {a : _} -> Var161 g a -> Var161 (snoc161 g B) a
vs161 = \ x, var, vz161, vs161 => vs161 _ _ _ (x var vz161 vs161)

Tm161 : Con161 -> Ty161 -> Type
Tm161 = \ g, a =>
    (Tm161    : Con161 -> Ty161 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var161 g a -> Tm161 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm161 (snoc161 g a) B -> Tm161 g (arr161 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm161 g (arr161 a B) -> Tm161 g a -> Tm161 g B)
 -> Tm161 g a

var161 : {g : _} -> {a : _} -> Var161 g a -> Tm161 g a
var161 = \ x, tm, var161, lam, app => var161 _ _ x

lam161 : {g : _} -> {a : _} -> {B : _} -> Tm161 (snoc161 g a) B -> Tm161 g (arr161 a B)
lam161 = \ t, tm, var161, lam161, app => lam161 _ _ _ (t tm var161 lam161 app)

app161 : {g:_}->{a:_}->{B:_} -> Tm161 g (arr161 a B) -> Tm161 g a -> Tm161 g B
app161 = \ t, u, tm, var161, lam161, app161 => app161 _ _ _ (t tm var161 lam161 app161) (u tm var161 lam161 app161)

v0161 : {g:_}->{a:_} -> Tm161 (snoc161 g a) a
v0161 = var161 vz161

v1161 : {g:_}->{a:_}-> {B:_}-> Tm161 (snoc161 (snoc161 g a) B) a
v1161 = var161 (vs161 vz161)

v2161 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm161 (snoc161 (snoc161 (snoc161 g a) B) C) a
v2161 = var161 (vs161 (vs161 vz161))

v3161 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm161 (snoc161 (snoc161 (snoc161 (snoc161 g a) B) C) D) a
v3161 = var161 (vs161 (vs161 (vs161 vz161)))

v4161 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm161 (snoc161 (snoc161 (snoc161 (snoc161 (snoc161 g a) B) C) D) E) a
v4161 = var161 (vs161 (vs161 (vs161 (vs161 vz161))))

test161 : {g:_}-> {a:_} -> Tm161 g (arr161 (arr161 a a) (arr161 a a))
test161  = lam161 (lam161 (app161 v1161 (app161 v1161 (app161 v1161 (app161 v1161 (app161 v1161 (app161 v1161 v0161)))))))
Ty162 : Type
Ty162 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty162 : Ty162
empty162 = \ _, empty, _ => empty

arr162 : Ty162 -> Ty162 -> Ty162
arr162 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con162 : Type
Con162 = (Con162 : Type)
 ->(nil  : Con162)
 ->(snoc : Con162 -> Ty162 -> Con162)
 -> Con162

nil162 : Con162
nil162 = \ con, nil162, snoc => nil162

snoc162 : Con162 -> Ty162 -> Con162
snoc162 = \ g, a, con, nil162, snoc162 => snoc162 (g con nil162 snoc162) a

Var162 : Con162 -> Ty162 -> Type
Var162 = \ g, a =>
    (Var162 : Con162 -> Ty162 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var162 (snoc162 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var162 g a -> Var162 (snoc162 g b) a)
 -> Var162 g a

vz162 : {g : _}-> {a : _} -> Var162 (snoc162 g a) a
vz162 = \ var, vz162, vs => vz162 _ _

vs162 : {g : _} -> {B : _} -> {a : _} -> Var162 g a -> Var162 (snoc162 g B) a
vs162 = \ x, var, vz162, vs162 => vs162 _ _ _ (x var vz162 vs162)

Tm162 : Con162 -> Ty162 -> Type
Tm162 = \ g, a =>
    (Tm162    : Con162 -> Ty162 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var162 g a -> Tm162 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm162 (snoc162 g a) B -> Tm162 g (arr162 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm162 g (arr162 a B) -> Tm162 g a -> Tm162 g B)
 -> Tm162 g a

var162 : {g : _} -> {a : _} -> Var162 g a -> Tm162 g a
var162 = \ x, tm, var162, lam, app => var162 _ _ x

lam162 : {g : _} -> {a : _} -> {B : _} -> Tm162 (snoc162 g a) B -> Tm162 g (arr162 a B)
lam162 = \ t, tm, var162, lam162, app => lam162 _ _ _ (t tm var162 lam162 app)

app162 : {g:_}->{a:_}->{B:_} -> Tm162 g (arr162 a B) -> Tm162 g a -> Tm162 g B
app162 = \ t, u, tm, var162, lam162, app162 => app162 _ _ _ (t tm var162 lam162 app162) (u tm var162 lam162 app162)

v0162 : {g:_}->{a:_} -> Tm162 (snoc162 g a) a
v0162 = var162 vz162

v1162 : {g:_}->{a:_}-> {B:_}-> Tm162 (snoc162 (snoc162 g a) B) a
v1162 = var162 (vs162 vz162)

v2162 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm162 (snoc162 (snoc162 (snoc162 g a) B) C) a
v2162 = var162 (vs162 (vs162 vz162))

v3162 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm162 (snoc162 (snoc162 (snoc162 (snoc162 g a) B) C) D) a
v3162 = var162 (vs162 (vs162 (vs162 vz162)))

v4162 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm162 (snoc162 (snoc162 (snoc162 (snoc162 (snoc162 g a) B) C) D) E) a
v4162 = var162 (vs162 (vs162 (vs162 (vs162 vz162))))

test162 : {g:_}-> {a:_} -> Tm162 g (arr162 (arr162 a a) (arr162 a a))
test162  = lam162 (lam162 (app162 v1162 (app162 v1162 (app162 v1162 (app162 v1162 (app162 v1162 (app162 v1162 v0162)))))))
Ty163 : Type
Ty163 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty163 : Ty163
empty163 = \ _, empty, _ => empty

arr163 : Ty163 -> Ty163 -> Ty163
arr163 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con163 : Type
Con163 = (Con163 : Type)
 ->(nil  : Con163)
 ->(snoc : Con163 -> Ty163 -> Con163)
 -> Con163

nil163 : Con163
nil163 = \ con, nil163, snoc => nil163

snoc163 : Con163 -> Ty163 -> Con163
snoc163 = \ g, a, con, nil163, snoc163 => snoc163 (g con nil163 snoc163) a

Var163 : Con163 -> Ty163 -> Type
Var163 = \ g, a =>
    (Var163 : Con163 -> Ty163 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var163 (snoc163 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var163 g a -> Var163 (snoc163 g b) a)
 -> Var163 g a

vz163 : {g : _}-> {a : _} -> Var163 (snoc163 g a) a
vz163 = \ var, vz163, vs => vz163 _ _

vs163 : {g : _} -> {B : _} -> {a : _} -> Var163 g a -> Var163 (snoc163 g B) a
vs163 = \ x, var, vz163, vs163 => vs163 _ _ _ (x var vz163 vs163)

Tm163 : Con163 -> Ty163 -> Type
Tm163 = \ g, a =>
    (Tm163    : Con163 -> Ty163 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var163 g a -> Tm163 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm163 (snoc163 g a) B -> Tm163 g (arr163 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm163 g (arr163 a B) -> Tm163 g a -> Tm163 g B)
 -> Tm163 g a

var163 : {g : _} -> {a : _} -> Var163 g a -> Tm163 g a
var163 = \ x, tm, var163, lam, app => var163 _ _ x

lam163 : {g : _} -> {a : _} -> {B : _} -> Tm163 (snoc163 g a) B -> Tm163 g (arr163 a B)
lam163 = \ t, tm, var163, lam163, app => lam163 _ _ _ (t tm var163 lam163 app)

app163 : {g:_}->{a:_}->{B:_} -> Tm163 g (arr163 a B) -> Tm163 g a -> Tm163 g B
app163 = \ t, u, tm, var163, lam163, app163 => app163 _ _ _ (t tm var163 lam163 app163) (u tm var163 lam163 app163)

v0163 : {g:_}->{a:_} -> Tm163 (snoc163 g a) a
v0163 = var163 vz163

v1163 : {g:_}->{a:_}-> {B:_}-> Tm163 (snoc163 (snoc163 g a) B) a
v1163 = var163 (vs163 vz163)

v2163 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm163 (snoc163 (snoc163 (snoc163 g a) B) C) a
v2163 = var163 (vs163 (vs163 vz163))

v3163 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm163 (snoc163 (snoc163 (snoc163 (snoc163 g a) B) C) D) a
v3163 = var163 (vs163 (vs163 (vs163 vz163)))

v4163 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm163 (snoc163 (snoc163 (snoc163 (snoc163 (snoc163 g a) B) C) D) E) a
v4163 = var163 (vs163 (vs163 (vs163 (vs163 vz163))))

test163 : {g:_}-> {a:_} -> Tm163 g (arr163 (arr163 a a) (arr163 a a))
test163  = lam163 (lam163 (app163 v1163 (app163 v1163 (app163 v1163 (app163 v1163 (app163 v1163 (app163 v1163 v0163)))))))
Ty164 : Type
Ty164 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty164 : Ty164
empty164 = \ _, empty, _ => empty

arr164 : Ty164 -> Ty164 -> Ty164
arr164 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con164 : Type
Con164 = (Con164 : Type)
 ->(nil  : Con164)
 ->(snoc : Con164 -> Ty164 -> Con164)
 -> Con164

nil164 : Con164
nil164 = \ con, nil164, snoc => nil164

snoc164 : Con164 -> Ty164 -> Con164
snoc164 = \ g, a, con, nil164, snoc164 => snoc164 (g con nil164 snoc164) a

Var164 : Con164 -> Ty164 -> Type
Var164 = \ g, a =>
    (Var164 : Con164 -> Ty164 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var164 (snoc164 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var164 g a -> Var164 (snoc164 g b) a)
 -> Var164 g a

vz164 : {g : _}-> {a : _} -> Var164 (snoc164 g a) a
vz164 = \ var, vz164, vs => vz164 _ _

vs164 : {g : _} -> {B : _} -> {a : _} -> Var164 g a -> Var164 (snoc164 g B) a
vs164 = \ x, var, vz164, vs164 => vs164 _ _ _ (x var vz164 vs164)

Tm164 : Con164 -> Ty164 -> Type
Tm164 = \ g, a =>
    (Tm164    : Con164 -> Ty164 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var164 g a -> Tm164 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm164 (snoc164 g a) B -> Tm164 g (arr164 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm164 g (arr164 a B) -> Tm164 g a -> Tm164 g B)
 -> Tm164 g a

var164 : {g : _} -> {a : _} -> Var164 g a -> Tm164 g a
var164 = \ x, tm, var164, lam, app => var164 _ _ x

lam164 : {g : _} -> {a : _} -> {B : _} -> Tm164 (snoc164 g a) B -> Tm164 g (arr164 a B)
lam164 = \ t, tm, var164, lam164, app => lam164 _ _ _ (t tm var164 lam164 app)

app164 : {g:_}->{a:_}->{B:_} -> Tm164 g (arr164 a B) -> Tm164 g a -> Tm164 g B
app164 = \ t, u, tm, var164, lam164, app164 => app164 _ _ _ (t tm var164 lam164 app164) (u tm var164 lam164 app164)

v0164 : {g:_}->{a:_} -> Tm164 (snoc164 g a) a
v0164 = var164 vz164

v1164 : {g:_}->{a:_}-> {B:_}-> Tm164 (snoc164 (snoc164 g a) B) a
v1164 = var164 (vs164 vz164)

v2164 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm164 (snoc164 (snoc164 (snoc164 g a) B) C) a
v2164 = var164 (vs164 (vs164 vz164))

v3164 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm164 (snoc164 (snoc164 (snoc164 (snoc164 g a) B) C) D) a
v3164 = var164 (vs164 (vs164 (vs164 vz164)))

v4164 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm164 (snoc164 (snoc164 (snoc164 (snoc164 (snoc164 g a) B) C) D) E) a
v4164 = var164 (vs164 (vs164 (vs164 (vs164 vz164))))

test164 : {g:_}-> {a:_} -> Tm164 g (arr164 (arr164 a a) (arr164 a a))
test164  = lam164 (lam164 (app164 v1164 (app164 v1164 (app164 v1164 (app164 v1164 (app164 v1164 (app164 v1164 v0164)))))))
Ty165 : Type
Ty165 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty165 : Ty165
empty165 = \ _, empty, _ => empty

arr165 : Ty165 -> Ty165 -> Ty165
arr165 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con165 : Type
Con165 = (Con165 : Type)
 ->(nil  : Con165)
 ->(snoc : Con165 -> Ty165 -> Con165)
 -> Con165

nil165 : Con165
nil165 = \ con, nil165, snoc => nil165

snoc165 : Con165 -> Ty165 -> Con165
snoc165 = \ g, a, con, nil165, snoc165 => snoc165 (g con nil165 snoc165) a

Var165 : Con165 -> Ty165 -> Type
Var165 = \ g, a =>
    (Var165 : Con165 -> Ty165 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var165 (snoc165 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var165 g a -> Var165 (snoc165 g b) a)
 -> Var165 g a

vz165 : {g : _}-> {a : _} -> Var165 (snoc165 g a) a
vz165 = \ var, vz165, vs => vz165 _ _

vs165 : {g : _} -> {B : _} -> {a : _} -> Var165 g a -> Var165 (snoc165 g B) a
vs165 = \ x, var, vz165, vs165 => vs165 _ _ _ (x var vz165 vs165)

Tm165 : Con165 -> Ty165 -> Type
Tm165 = \ g, a =>
    (Tm165    : Con165 -> Ty165 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var165 g a -> Tm165 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm165 (snoc165 g a) B -> Tm165 g (arr165 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm165 g (arr165 a B) -> Tm165 g a -> Tm165 g B)
 -> Tm165 g a

var165 : {g : _} -> {a : _} -> Var165 g a -> Tm165 g a
var165 = \ x, tm, var165, lam, app => var165 _ _ x

lam165 : {g : _} -> {a : _} -> {B : _} -> Tm165 (snoc165 g a) B -> Tm165 g (arr165 a B)
lam165 = \ t, tm, var165, lam165, app => lam165 _ _ _ (t tm var165 lam165 app)

app165 : {g:_}->{a:_}->{B:_} -> Tm165 g (arr165 a B) -> Tm165 g a -> Tm165 g B
app165 = \ t, u, tm, var165, lam165, app165 => app165 _ _ _ (t tm var165 lam165 app165) (u tm var165 lam165 app165)

v0165 : {g:_}->{a:_} -> Tm165 (snoc165 g a) a
v0165 = var165 vz165

v1165 : {g:_}->{a:_}-> {B:_}-> Tm165 (snoc165 (snoc165 g a) B) a
v1165 = var165 (vs165 vz165)

v2165 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm165 (snoc165 (snoc165 (snoc165 g a) B) C) a
v2165 = var165 (vs165 (vs165 vz165))

v3165 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm165 (snoc165 (snoc165 (snoc165 (snoc165 g a) B) C) D) a
v3165 = var165 (vs165 (vs165 (vs165 vz165)))

v4165 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm165 (snoc165 (snoc165 (snoc165 (snoc165 (snoc165 g a) B) C) D) E) a
v4165 = var165 (vs165 (vs165 (vs165 (vs165 vz165))))

test165 : {g:_}-> {a:_} -> Tm165 g (arr165 (arr165 a a) (arr165 a a))
test165  = lam165 (lam165 (app165 v1165 (app165 v1165 (app165 v1165 (app165 v1165 (app165 v1165 (app165 v1165 v0165)))))))
Ty166 : Type
Ty166 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty166 : Ty166
empty166 = \ _, empty, _ => empty

arr166 : Ty166 -> Ty166 -> Ty166
arr166 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con166 : Type
Con166 = (Con166 : Type)
 ->(nil  : Con166)
 ->(snoc : Con166 -> Ty166 -> Con166)
 -> Con166

nil166 : Con166
nil166 = \ con, nil166, snoc => nil166

snoc166 : Con166 -> Ty166 -> Con166
snoc166 = \ g, a, con, nil166, snoc166 => snoc166 (g con nil166 snoc166) a

Var166 : Con166 -> Ty166 -> Type
Var166 = \ g, a =>
    (Var166 : Con166 -> Ty166 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var166 (snoc166 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var166 g a -> Var166 (snoc166 g b) a)
 -> Var166 g a

vz166 : {g : _}-> {a : _} -> Var166 (snoc166 g a) a
vz166 = \ var, vz166, vs => vz166 _ _

vs166 : {g : _} -> {B : _} -> {a : _} -> Var166 g a -> Var166 (snoc166 g B) a
vs166 = \ x, var, vz166, vs166 => vs166 _ _ _ (x var vz166 vs166)

Tm166 : Con166 -> Ty166 -> Type
Tm166 = \ g, a =>
    (Tm166    : Con166 -> Ty166 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var166 g a -> Tm166 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm166 (snoc166 g a) B -> Tm166 g (arr166 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm166 g (arr166 a B) -> Tm166 g a -> Tm166 g B)
 -> Tm166 g a

var166 : {g : _} -> {a : _} -> Var166 g a -> Tm166 g a
var166 = \ x, tm, var166, lam, app => var166 _ _ x

lam166 : {g : _} -> {a : _} -> {B : _} -> Tm166 (snoc166 g a) B -> Tm166 g (arr166 a B)
lam166 = \ t, tm, var166, lam166, app => lam166 _ _ _ (t tm var166 lam166 app)

app166 : {g:_}->{a:_}->{B:_} -> Tm166 g (arr166 a B) -> Tm166 g a -> Tm166 g B
app166 = \ t, u, tm, var166, lam166, app166 => app166 _ _ _ (t tm var166 lam166 app166) (u tm var166 lam166 app166)

v0166 : {g:_}->{a:_} -> Tm166 (snoc166 g a) a
v0166 = var166 vz166

v1166 : {g:_}->{a:_}-> {B:_}-> Tm166 (snoc166 (snoc166 g a) B) a
v1166 = var166 (vs166 vz166)

v2166 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm166 (snoc166 (snoc166 (snoc166 g a) B) C) a
v2166 = var166 (vs166 (vs166 vz166))

v3166 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm166 (snoc166 (snoc166 (snoc166 (snoc166 g a) B) C) D) a
v3166 = var166 (vs166 (vs166 (vs166 vz166)))

v4166 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm166 (snoc166 (snoc166 (snoc166 (snoc166 (snoc166 g a) B) C) D) E) a
v4166 = var166 (vs166 (vs166 (vs166 (vs166 vz166))))

test166 : {g:_}-> {a:_} -> Tm166 g (arr166 (arr166 a a) (arr166 a a))
test166  = lam166 (lam166 (app166 v1166 (app166 v1166 (app166 v1166 (app166 v1166 (app166 v1166 (app166 v1166 v0166)))))))
Ty167 : Type
Ty167 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty167 : Ty167
empty167 = \ _, empty, _ => empty

arr167 : Ty167 -> Ty167 -> Ty167
arr167 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con167 : Type
Con167 = (Con167 : Type)
 ->(nil  : Con167)
 ->(snoc : Con167 -> Ty167 -> Con167)
 -> Con167

nil167 : Con167
nil167 = \ con, nil167, snoc => nil167

snoc167 : Con167 -> Ty167 -> Con167
snoc167 = \ g, a, con, nil167, snoc167 => snoc167 (g con nil167 snoc167) a

Var167 : Con167 -> Ty167 -> Type
Var167 = \ g, a =>
    (Var167 : Con167 -> Ty167 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var167 (snoc167 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var167 g a -> Var167 (snoc167 g b) a)
 -> Var167 g a

vz167 : {g : _}-> {a : _} -> Var167 (snoc167 g a) a
vz167 = \ var, vz167, vs => vz167 _ _

vs167 : {g : _} -> {B : _} -> {a : _} -> Var167 g a -> Var167 (snoc167 g B) a
vs167 = \ x, var, vz167, vs167 => vs167 _ _ _ (x var vz167 vs167)

Tm167 : Con167 -> Ty167 -> Type
Tm167 = \ g, a =>
    (Tm167    : Con167 -> Ty167 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var167 g a -> Tm167 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm167 (snoc167 g a) B -> Tm167 g (arr167 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm167 g (arr167 a B) -> Tm167 g a -> Tm167 g B)
 -> Tm167 g a

var167 : {g : _} -> {a : _} -> Var167 g a -> Tm167 g a
var167 = \ x, tm, var167, lam, app => var167 _ _ x

lam167 : {g : _} -> {a : _} -> {B : _} -> Tm167 (snoc167 g a) B -> Tm167 g (arr167 a B)
lam167 = \ t, tm, var167, lam167, app => lam167 _ _ _ (t tm var167 lam167 app)

app167 : {g:_}->{a:_}->{B:_} -> Tm167 g (arr167 a B) -> Tm167 g a -> Tm167 g B
app167 = \ t, u, tm, var167, lam167, app167 => app167 _ _ _ (t tm var167 lam167 app167) (u tm var167 lam167 app167)

v0167 : {g:_}->{a:_} -> Tm167 (snoc167 g a) a
v0167 = var167 vz167

v1167 : {g:_}->{a:_}-> {B:_}-> Tm167 (snoc167 (snoc167 g a) B) a
v1167 = var167 (vs167 vz167)

v2167 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm167 (snoc167 (snoc167 (snoc167 g a) B) C) a
v2167 = var167 (vs167 (vs167 vz167))

v3167 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm167 (snoc167 (snoc167 (snoc167 (snoc167 g a) B) C) D) a
v3167 = var167 (vs167 (vs167 (vs167 vz167)))

v4167 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm167 (snoc167 (snoc167 (snoc167 (snoc167 (snoc167 g a) B) C) D) E) a
v4167 = var167 (vs167 (vs167 (vs167 (vs167 vz167))))

test167 : {g:_}-> {a:_} -> Tm167 g (arr167 (arr167 a a) (arr167 a a))
test167  = lam167 (lam167 (app167 v1167 (app167 v1167 (app167 v1167 (app167 v1167 (app167 v1167 (app167 v1167 v0167)))))))
Ty168 : Type
Ty168 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty168 : Ty168
empty168 = \ _, empty, _ => empty

arr168 : Ty168 -> Ty168 -> Ty168
arr168 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con168 : Type
Con168 = (Con168 : Type)
 ->(nil  : Con168)
 ->(snoc : Con168 -> Ty168 -> Con168)
 -> Con168

nil168 : Con168
nil168 = \ con, nil168, snoc => nil168

snoc168 : Con168 -> Ty168 -> Con168
snoc168 = \ g, a, con, nil168, snoc168 => snoc168 (g con nil168 snoc168) a

Var168 : Con168 -> Ty168 -> Type
Var168 = \ g, a =>
    (Var168 : Con168 -> Ty168 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var168 (snoc168 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var168 g a -> Var168 (snoc168 g b) a)
 -> Var168 g a

vz168 : {g : _}-> {a : _} -> Var168 (snoc168 g a) a
vz168 = \ var, vz168, vs => vz168 _ _

vs168 : {g : _} -> {B : _} -> {a : _} -> Var168 g a -> Var168 (snoc168 g B) a
vs168 = \ x, var, vz168, vs168 => vs168 _ _ _ (x var vz168 vs168)

Tm168 : Con168 -> Ty168 -> Type
Tm168 = \ g, a =>
    (Tm168    : Con168 -> Ty168 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var168 g a -> Tm168 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm168 (snoc168 g a) B -> Tm168 g (arr168 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm168 g (arr168 a B) -> Tm168 g a -> Tm168 g B)
 -> Tm168 g a

var168 : {g : _} -> {a : _} -> Var168 g a -> Tm168 g a
var168 = \ x, tm, var168, lam, app => var168 _ _ x

lam168 : {g : _} -> {a : _} -> {B : _} -> Tm168 (snoc168 g a) B -> Tm168 g (arr168 a B)
lam168 = \ t, tm, var168, lam168, app => lam168 _ _ _ (t tm var168 lam168 app)

app168 : {g:_}->{a:_}->{B:_} -> Tm168 g (arr168 a B) -> Tm168 g a -> Tm168 g B
app168 = \ t, u, tm, var168, lam168, app168 => app168 _ _ _ (t tm var168 lam168 app168) (u tm var168 lam168 app168)

v0168 : {g:_}->{a:_} -> Tm168 (snoc168 g a) a
v0168 = var168 vz168

v1168 : {g:_}->{a:_}-> {B:_}-> Tm168 (snoc168 (snoc168 g a) B) a
v1168 = var168 (vs168 vz168)

v2168 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm168 (snoc168 (snoc168 (snoc168 g a) B) C) a
v2168 = var168 (vs168 (vs168 vz168))

v3168 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm168 (snoc168 (snoc168 (snoc168 (snoc168 g a) B) C) D) a
v3168 = var168 (vs168 (vs168 (vs168 vz168)))

v4168 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm168 (snoc168 (snoc168 (snoc168 (snoc168 (snoc168 g a) B) C) D) E) a
v4168 = var168 (vs168 (vs168 (vs168 (vs168 vz168))))

test168 : {g:_}-> {a:_} -> Tm168 g (arr168 (arr168 a a) (arr168 a a))
test168  = lam168 (lam168 (app168 v1168 (app168 v1168 (app168 v1168 (app168 v1168 (app168 v1168 (app168 v1168 v0168)))))))
Ty169 : Type
Ty169 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty169 : Ty169
empty169 = \ _, empty, _ => empty

arr169 : Ty169 -> Ty169 -> Ty169
arr169 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con169 : Type
Con169 = (Con169 : Type)
 ->(nil  : Con169)
 ->(snoc : Con169 -> Ty169 -> Con169)
 -> Con169

nil169 : Con169
nil169 = \ con, nil169, snoc => nil169

snoc169 : Con169 -> Ty169 -> Con169
snoc169 = \ g, a, con, nil169, snoc169 => snoc169 (g con nil169 snoc169) a

Var169 : Con169 -> Ty169 -> Type
Var169 = \ g, a =>
    (Var169 : Con169 -> Ty169 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var169 (snoc169 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var169 g a -> Var169 (snoc169 g b) a)
 -> Var169 g a

vz169 : {g : _}-> {a : _} -> Var169 (snoc169 g a) a
vz169 = \ var, vz169, vs => vz169 _ _

vs169 : {g : _} -> {B : _} -> {a : _} -> Var169 g a -> Var169 (snoc169 g B) a
vs169 = \ x, var, vz169, vs169 => vs169 _ _ _ (x var vz169 vs169)

Tm169 : Con169 -> Ty169 -> Type
Tm169 = \ g, a =>
    (Tm169    : Con169 -> Ty169 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var169 g a -> Tm169 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm169 (snoc169 g a) B -> Tm169 g (arr169 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm169 g (arr169 a B) -> Tm169 g a -> Tm169 g B)
 -> Tm169 g a

var169 : {g : _} -> {a : _} -> Var169 g a -> Tm169 g a
var169 = \ x, tm, var169, lam, app => var169 _ _ x

lam169 : {g : _} -> {a : _} -> {B : _} -> Tm169 (snoc169 g a) B -> Tm169 g (arr169 a B)
lam169 = \ t, tm, var169, lam169, app => lam169 _ _ _ (t tm var169 lam169 app)

app169 : {g:_}->{a:_}->{B:_} -> Tm169 g (arr169 a B) -> Tm169 g a -> Tm169 g B
app169 = \ t, u, tm, var169, lam169, app169 => app169 _ _ _ (t tm var169 lam169 app169) (u tm var169 lam169 app169)

v0169 : {g:_}->{a:_} -> Tm169 (snoc169 g a) a
v0169 = var169 vz169

v1169 : {g:_}->{a:_}-> {B:_}-> Tm169 (snoc169 (snoc169 g a) B) a
v1169 = var169 (vs169 vz169)

v2169 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm169 (snoc169 (snoc169 (snoc169 g a) B) C) a
v2169 = var169 (vs169 (vs169 vz169))

v3169 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm169 (snoc169 (snoc169 (snoc169 (snoc169 g a) B) C) D) a
v3169 = var169 (vs169 (vs169 (vs169 vz169)))

v4169 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm169 (snoc169 (snoc169 (snoc169 (snoc169 (snoc169 g a) B) C) D) E) a
v4169 = var169 (vs169 (vs169 (vs169 (vs169 vz169))))

test169 : {g:_}-> {a:_} -> Tm169 g (arr169 (arr169 a a) (arr169 a a))
test169  = lam169 (lam169 (app169 v1169 (app169 v1169 (app169 v1169 (app169 v1169 (app169 v1169 (app169 v1169 v0169)))))))
Ty170 : Type
Ty170 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty170 : Ty170
empty170 = \ _, empty, _ => empty

arr170 : Ty170 -> Ty170 -> Ty170
arr170 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con170 : Type
Con170 = (Con170 : Type)
 ->(nil  : Con170)
 ->(snoc : Con170 -> Ty170 -> Con170)
 -> Con170

nil170 : Con170
nil170 = \ con, nil170, snoc => nil170

snoc170 : Con170 -> Ty170 -> Con170
snoc170 = \ g, a, con, nil170, snoc170 => snoc170 (g con nil170 snoc170) a

Var170 : Con170 -> Ty170 -> Type
Var170 = \ g, a =>
    (Var170 : Con170 -> Ty170 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var170 (snoc170 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var170 g a -> Var170 (snoc170 g b) a)
 -> Var170 g a

vz170 : {g : _}-> {a : _} -> Var170 (snoc170 g a) a
vz170 = \ var, vz170, vs => vz170 _ _

vs170 : {g : _} -> {B : _} -> {a : _} -> Var170 g a -> Var170 (snoc170 g B) a
vs170 = \ x, var, vz170, vs170 => vs170 _ _ _ (x var vz170 vs170)

Tm170 : Con170 -> Ty170 -> Type
Tm170 = \ g, a =>
    (Tm170    : Con170 -> Ty170 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var170 g a -> Tm170 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm170 (snoc170 g a) B -> Tm170 g (arr170 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm170 g (arr170 a B) -> Tm170 g a -> Tm170 g B)
 -> Tm170 g a

var170 : {g : _} -> {a : _} -> Var170 g a -> Tm170 g a
var170 = \ x, tm, var170, lam, app => var170 _ _ x

lam170 : {g : _} -> {a : _} -> {B : _} -> Tm170 (snoc170 g a) B -> Tm170 g (arr170 a B)
lam170 = \ t, tm, var170, lam170, app => lam170 _ _ _ (t tm var170 lam170 app)

app170 : {g:_}->{a:_}->{B:_} -> Tm170 g (arr170 a B) -> Tm170 g a -> Tm170 g B
app170 = \ t, u, tm, var170, lam170, app170 => app170 _ _ _ (t tm var170 lam170 app170) (u tm var170 lam170 app170)

v0170 : {g:_}->{a:_} -> Tm170 (snoc170 g a) a
v0170 = var170 vz170

v1170 : {g:_}->{a:_}-> {B:_}-> Tm170 (snoc170 (snoc170 g a) B) a
v1170 = var170 (vs170 vz170)

v2170 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm170 (snoc170 (snoc170 (snoc170 g a) B) C) a
v2170 = var170 (vs170 (vs170 vz170))

v3170 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm170 (snoc170 (snoc170 (snoc170 (snoc170 g a) B) C) D) a
v3170 = var170 (vs170 (vs170 (vs170 vz170)))

v4170 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm170 (snoc170 (snoc170 (snoc170 (snoc170 (snoc170 g a) B) C) D) E) a
v4170 = var170 (vs170 (vs170 (vs170 (vs170 vz170))))

test170 : {g:_}-> {a:_} -> Tm170 g (arr170 (arr170 a a) (arr170 a a))
test170  = lam170 (lam170 (app170 v1170 (app170 v1170 (app170 v1170 (app170 v1170 (app170 v1170 (app170 v1170 v0170)))))))
Ty171 : Type
Ty171 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty171 : Ty171
empty171 = \ _, empty, _ => empty

arr171 : Ty171 -> Ty171 -> Ty171
arr171 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con171 : Type
Con171 = (Con171 : Type)
 ->(nil  : Con171)
 ->(snoc : Con171 -> Ty171 -> Con171)
 -> Con171

nil171 : Con171
nil171 = \ con, nil171, snoc => nil171

snoc171 : Con171 -> Ty171 -> Con171
snoc171 = \ g, a, con, nil171, snoc171 => snoc171 (g con nil171 snoc171) a

Var171 : Con171 -> Ty171 -> Type
Var171 = \ g, a =>
    (Var171 : Con171 -> Ty171 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var171 (snoc171 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var171 g a -> Var171 (snoc171 g b) a)
 -> Var171 g a

vz171 : {g : _}-> {a : _} -> Var171 (snoc171 g a) a
vz171 = \ var, vz171, vs => vz171 _ _

vs171 : {g : _} -> {B : _} -> {a : _} -> Var171 g a -> Var171 (snoc171 g B) a
vs171 = \ x, var, vz171, vs171 => vs171 _ _ _ (x var vz171 vs171)

Tm171 : Con171 -> Ty171 -> Type
Tm171 = \ g, a =>
    (Tm171    : Con171 -> Ty171 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var171 g a -> Tm171 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm171 (snoc171 g a) B -> Tm171 g (arr171 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm171 g (arr171 a B) -> Tm171 g a -> Tm171 g B)
 -> Tm171 g a

var171 : {g : _} -> {a : _} -> Var171 g a -> Tm171 g a
var171 = \ x, tm, var171, lam, app => var171 _ _ x

lam171 : {g : _} -> {a : _} -> {B : _} -> Tm171 (snoc171 g a) B -> Tm171 g (arr171 a B)
lam171 = \ t, tm, var171, lam171, app => lam171 _ _ _ (t tm var171 lam171 app)

app171 : {g:_}->{a:_}->{B:_} -> Tm171 g (arr171 a B) -> Tm171 g a -> Tm171 g B
app171 = \ t, u, tm, var171, lam171, app171 => app171 _ _ _ (t tm var171 lam171 app171) (u tm var171 lam171 app171)

v0171 : {g:_}->{a:_} -> Tm171 (snoc171 g a) a
v0171 = var171 vz171

v1171 : {g:_}->{a:_}-> {B:_}-> Tm171 (snoc171 (snoc171 g a) B) a
v1171 = var171 (vs171 vz171)

v2171 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm171 (snoc171 (snoc171 (snoc171 g a) B) C) a
v2171 = var171 (vs171 (vs171 vz171))

v3171 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm171 (snoc171 (snoc171 (snoc171 (snoc171 g a) B) C) D) a
v3171 = var171 (vs171 (vs171 (vs171 vz171)))

v4171 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm171 (snoc171 (snoc171 (snoc171 (snoc171 (snoc171 g a) B) C) D) E) a
v4171 = var171 (vs171 (vs171 (vs171 (vs171 vz171))))

test171 : {g:_}-> {a:_} -> Tm171 g (arr171 (arr171 a a) (arr171 a a))
test171  = lam171 (lam171 (app171 v1171 (app171 v1171 (app171 v1171 (app171 v1171 (app171 v1171 (app171 v1171 v0171)))))))
Ty172 : Type
Ty172 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty172 : Ty172
empty172 = \ _, empty, _ => empty

arr172 : Ty172 -> Ty172 -> Ty172
arr172 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con172 : Type
Con172 = (Con172 : Type)
 ->(nil  : Con172)
 ->(snoc : Con172 -> Ty172 -> Con172)
 -> Con172

nil172 : Con172
nil172 = \ con, nil172, snoc => nil172

snoc172 : Con172 -> Ty172 -> Con172
snoc172 = \ g, a, con, nil172, snoc172 => snoc172 (g con nil172 snoc172) a

Var172 : Con172 -> Ty172 -> Type
Var172 = \ g, a =>
    (Var172 : Con172 -> Ty172 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var172 (snoc172 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var172 g a -> Var172 (snoc172 g b) a)
 -> Var172 g a

vz172 : {g : _}-> {a : _} -> Var172 (snoc172 g a) a
vz172 = \ var, vz172, vs => vz172 _ _

vs172 : {g : _} -> {B : _} -> {a : _} -> Var172 g a -> Var172 (snoc172 g B) a
vs172 = \ x, var, vz172, vs172 => vs172 _ _ _ (x var vz172 vs172)

Tm172 : Con172 -> Ty172 -> Type
Tm172 = \ g, a =>
    (Tm172    : Con172 -> Ty172 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var172 g a -> Tm172 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm172 (snoc172 g a) B -> Tm172 g (arr172 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm172 g (arr172 a B) -> Tm172 g a -> Tm172 g B)
 -> Tm172 g a

var172 : {g : _} -> {a : _} -> Var172 g a -> Tm172 g a
var172 = \ x, tm, var172, lam, app => var172 _ _ x

lam172 : {g : _} -> {a : _} -> {B : _} -> Tm172 (snoc172 g a) B -> Tm172 g (arr172 a B)
lam172 = \ t, tm, var172, lam172, app => lam172 _ _ _ (t tm var172 lam172 app)

app172 : {g:_}->{a:_}->{B:_} -> Tm172 g (arr172 a B) -> Tm172 g a -> Tm172 g B
app172 = \ t, u, tm, var172, lam172, app172 => app172 _ _ _ (t tm var172 lam172 app172) (u tm var172 lam172 app172)

v0172 : {g:_}->{a:_} -> Tm172 (snoc172 g a) a
v0172 = var172 vz172

v1172 : {g:_}->{a:_}-> {B:_}-> Tm172 (snoc172 (snoc172 g a) B) a
v1172 = var172 (vs172 vz172)

v2172 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm172 (snoc172 (snoc172 (snoc172 g a) B) C) a
v2172 = var172 (vs172 (vs172 vz172))

v3172 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm172 (snoc172 (snoc172 (snoc172 (snoc172 g a) B) C) D) a
v3172 = var172 (vs172 (vs172 (vs172 vz172)))

v4172 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm172 (snoc172 (snoc172 (snoc172 (snoc172 (snoc172 g a) B) C) D) E) a
v4172 = var172 (vs172 (vs172 (vs172 (vs172 vz172))))

test172 : {g:_}-> {a:_} -> Tm172 g (arr172 (arr172 a a) (arr172 a a))
test172  = lam172 (lam172 (app172 v1172 (app172 v1172 (app172 v1172 (app172 v1172 (app172 v1172 (app172 v1172 v0172)))))))
Ty173 : Type
Ty173 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty173 : Ty173
empty173 = \ _, empty, _ => empty

arr173 : Ty173 -> Ty173 -> Ty173
arr173 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con173 : Type
Con173 = (Con173 : Type)
 ->(nil  : Con173)
 ->(snoc : Con173 -> Ty173 -> Con173)
 -> Con173

nil173 : Con173
nil173 = \ con, nil173, snoc => nil173

snoc173 : Con173 -> Ty173 -> Con173
snoc173 = \ g, a, con, nil173, snoc173 => snoc173 (g con nil173 snoc173) a

Var173 : Con173 -> Ty173 -> Type
Var173 = \ g, a =>
    (Var173 : Con173 -> Ty173 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var173 (snoc173 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var173 g a -> Var173 (snoc173 g b) a)
 -> Var173 g a

vz173 : {g : _}-> {a : _} -> Var173 (snoc173 g a) a
vz173 = \ var, vz173, vs => vz173 _ _

vs173 : {g : _} -> {B : _} -> {a : _} -> Var173 g a -> Var173 (snoc173 g B) a
vs173 = \ x, var, vz173, vs173 => vs173 _ _ _ (x var vz173 vs173)

Tm173 : Con173 -> Ty173 -> Type
Tm173 = \ g, a =>
    (Tm173    : Con173 -> Ty173 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var173 g a -> Tm173 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm173 (snoc173 g a) B -> Tm173 g (arr173 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm173 g (arr173 a B) -> Tm173 g a -> Tm173 g B)
 -> Tm173 g a

var173 : {g : _} -> {a : _} -> Var173 g a -> Tm173 g a
var173 = \ x, tm, var173, lam, app => var173 _ _ x

lam173 : {g : _} -> {a : _} -> {B : _} -> Tm173 (snoc173 g a) B -> Tm173 g (arr173 a B)
lam173 = \ t, tm, var173, lam173, app => lam173 _ _ _ (t tm var173 lam173 app)

app173 : {g:_}->{a:_}->{B:_} -> Tm173 g (arr173 a B) -> Tm173 g a -> Tm173 g B
app173 = \ t, u, tm, var173, lam173, app173 => app173 _ _ _ (t tm var173 lam173 app173) (u tm var173 lam173 app173)

v0173 : {g:_}->{a:_} -> Tm173 (snoc173 g a) a
v0173 = var173 vz173

v1173 : {g:_}->{a:_}-> {B:_}-> Tm173 (snoc173 (snoc173 g a) B) a
v1173 = var173 (vs173 vz173)

v2173 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm173 (snoc173 (snoc173 (snoc173 g a) B) C) a
v2173 = var173 (vs173 (vs173 vz173))

v3173 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm173 (snoc173 (snoc173 (snoc173 (snoc173 g a) B) C) D) a
v3173 = var173 (vs173 (vs173 (vs173 vz173)))

v4173 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm173 (snoc173 (snoc173 (snoc173 (snoc173 (snoc173 g a) B) C) D) E) a
v4173 = var173 (vs173 (vs173 (vs173 (vs173 vz173))))

test173 : {g:_}-> {a:_} -> Tm173 g (arr173 (arr173 a a) (arr173 a a))
test173  = lam173 (lam173 (app173 v1173 (app173 v1173 (app173 v1173 (app173 v1173 (app173 v1173 (app173 v1173 v0173)))))))
Ty174 : Type
Ty174 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty174 : Ty174
empty174 = \ _, empty, _ => empty

arr174 : Ty174 -> Ty174 -> Ty174
arr174 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con174 : Type
Con174 = (Con174 : Type)
 ->(nil  : Con174)
 ->(snoc : Con174 -> Ty174 -> Con174)
 -> Con174

nil174 : Con174
nil174 = \ con, nil174, snoc => nil174

snoc174 : Con174 -> Ty174 -> Con174
snoc174 = \ g, a, con, nil174, snoc174 => snoc174 (g con nil174 snoc174) a

Var174 : Con174 -> Ty174 -> Type
Var174 = \ g, a =>
    (Var174 : Con174 -> Ty174 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var174 (snoc174 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var174 g a -> Var174 (snoc174 g b) a)
 -> Var174 g a

vz174 : {g : _}-> {a : _} -> Var174 (snoc174 g a) a
vz174 = \ var, vz174, vs => vz174 _ _

vs174 : {g : _} -> {B : _} -> {a : _} -> Var174 g a -> Var174 (snoc174 g B) a
vs174 = \ x, var, vz174, vs174 => vs174 _ _ _ (x var vz174 vs174)

Tm174 : Con174 -> Ty174 -> Type
Tm174 = \ g, a =>
    (Tm174    : Con174 -> Ty174 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var174 g a -> Tm174 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm174 (snoc174 g a) B -> Tm174 g (arr174 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm174 g (arr174 a B) -> Tm174 g a -> Tm174 g B)
 -> Tm174 g a

var174 : {g : _} -> {a : _} -> Var174 g a -> Tm174 g a
var174 = \ x, tm, var174, lam, app => var174 _ _ x

lam174 : {g : _} -> {a : _} -> {B : _} -> Tm174 (snoc174 g a) B -> Tm174 g (arr174 a B)
lam174 = \ t, tm, var174, lam174, app => lam174 _ _ _ (t tm var174 lam174 app)

app174 : {g:_}->{a:_}->{B:_} -> Tm174 g (arr174 a B) -> Tm174 g a -> Tm174 g B
app174 = \ t, u, tm, var174, lam174, app174 => app174 _ _ _ (t tm var174 lam174 app174) (u tm var174 lam174 app174)

v0174 : {g:_}->{a:_} -> Tm174 (snoc174 g a) a
v0174 = var174 vz174

v1174 : {g:_}->{a:_}-> {B:_}-> Tm174 (snoc174 (snoc174 g a) B) a
v1174 = var174 (vs174 vz174)

v2174 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm174 (snoc174 (snoc174 (snoc174 g a) B) C) a
v2174 = var174 (vs174 (vs174 vz174))

v3174 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm174 (snoc174 (snoc174 (snoc174 (snoc174 g a) B) C) D) a
v3174 = var174 (vs174 (vs174 (vs174 vz174)))

v4174 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm174 (snoc174 (snoc174 (snoc174 (snoc174 (snoc174 g a) B) C) D) E) a
v4174 = var174 (vs174 (vs174 (vs174 (vs174 vz174))))

test174 : {g:_}-> {a:_} -> Tm174 g (arr174 (arr174 a a) (arr174 a a))
test174  = lam174 (lam174 (app174 v1174 (app174 v1174 (app174 v1174 (app174 v1174 (app174 v1174 (app174 v1174 v0174)))))))
Ty175 : Type
Ty175 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty175 : Ty175
empty175 = \ _, empty, _ => empty

arr175 : Ty175 -> Ty175 -> Ty175
arr175 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con175 : Type
Con175 = (Con175 : Type)
 ->(nil  : Con175)
 ->(snoc : Con175 -> Ty175 -> Con175)
 -> Con175

nil175 : Con175
nil175 = \ con, nil175, snoc => nil175

snoc175 : Con175 -> Ty175 -> Con175
snoc175 = \ g, a, con, nil175, snoc175 => snoc175 (g con nil175 snoc175) a

Var175 : Con175 -> Ty175 -> Type
Var175 = \ g, a =>
    (Var175 : Con175 -> Ty175 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var175 (snoc175 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var175 g a -> Var175 (snoc175 g b) a)
 -> Var175 g a

vz175 : {g : _}-> {a : _} -> Var175 (snoc175 g a) a
vz175 = \ var, vz175, vs => vz175 _ _

vs175 : {g : _} -> {B : _} -> {a : _} -> Var175 g a -> Var175 (snoc175 g B) a
vs175 = \ x, var, vz175, vs175 => vs175 _ _ _ (x var vz175 vs175)

Tm175 : Con175 -> Ty175 -> Type
Tm175 = \ g, a =>
    (Tm175    : Con175 -> Ty175 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var175 g a -> Tm175 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm175 (snoc175 g a) B -> Tm175 g (arr175 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm175 g (arr175 a B) -> Tm175 g a -> Tm175 g B)
 -> Tm175 g a

var175 : {g : _} -> {a : _} -> Var175 g a -> Tm175 g a
var175 = \ x, tm, var175, lam, app => var175 _ _ x

lam175 : {g : _} -> {a : _} -> {B : _} -> Tm175 (snoc175 g a) B -> Tm175 g (arr175 a B)
lam175 = \ t, tm, var175, lam175, app => lam175 _ _ _ (t tm var175 lam175 app)

app175 : {g:_}->{a:_}->{B:_} -> Tm175 g (arr175 a B) -> Tm175 g a -> Tm175 g B
app175 = \ t, u, tm, var175, lam175, app175 => app175 _ _ _ (t tm var175 lam175 app175) (u tm var175 lam175 app175)

v0175 : {g:_}->{a:_} -> Tm175 (snoc175 g a) a
v0175 = var175 vz175

v1175 : {g:_}->{a:_}-> {B:_}-> Tm175 (snoc175 (snoc175 g a) B) a
v1175 = var175 (vs175 vz175)

v2175 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm175 (snoc175 (snoc175 (snoc175 g a) B) C) a
v2175 = var175 (vs175 (vs175 vz175))

v3175 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm175 (snoc175 (snoc175 (snoc175 (snoc175 g a) B) C) D) a
v3175 = var175 (vs175 (vs175 (vs175 vz175)))

v4175 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm175 (snoc175 (snoc175 (snoc175 (snoc175 (snoc175 g a) B) C) D) E) a
v4175 = var175 (vs175 (vs175 (vs175 (vs175 vz175))))

test175 : {g:_}-> {a:_} -> Tm175 g (arr175 (arr175 a a) (arr175 a a))
test175  = lam175 (lam175 (app175 v1175 (app175 v1175 (app175 v1175 (app175 v1175 (app175 v1175 (app175 v1175 v0175)))))))
Ty176 : Type
Ty176 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty176 : Ty176
empty176 = \ _, empty, _ => empty

arr176 : Ty176 -> Ty176 -> Ty176
arr176 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con176 : Type
Con176 = (Con176 : Type)
 ->(nil  : Con176)
 ->(snoc : Con176 -> Ty176 -> Con176)
 -> Con176

nil176 : Con176
nil176 = \ con, nil176, snoc => nil176

snoc176 : Con176 -> Ty176 -> Con176
snoc176 = \ g, a, con, nil176, snoc176 => snoc176 (g con nil176 snoc176) a

Var176 : Con176 -> Ty176 -> Type
Var176 = \ g, a =>
    (Var176 : Con176 -> Ty176 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var176 (snoc176 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var176 g a -> Var176 (snoc176 g b) a)
 -> Var176 g a

vz176 : {g : _}-> {a : _} -> Var176 (snoc176 g a) a
vz176 = \ var, vz176, vs => vz176 _ _

vs176 : {g : _} -> {B : _} -> {a : _} -> Var176 g a -> Var176 (snoc176 g B) a
vs176 = \ x, var, vz176, vs176 => vs176 _ _ _ (x var vz176 vs176)

Tm176 : Con176 -> Ty176 -> Type
Tm176 = \ g, a =>
    (Tm176    : Con176 -> Ty176 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var176 g a -> Tm176 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm176 (snoc176 g a) B -> Tm176 g (arr176 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm176 g (arr176 a B) -> Tm176 g a -> Tm176 g B)
 -> Tm176 g a

var176 : {g : _} -> {a : _} -> Var176 g a -> Tm176 g a
var176 = \ x, tm, var176, lam, app => var176 _ _ x

lam176 : {g : _} -> {a : _} -> {B : _} -> Tm176 (snoc176 g a) B -> Tm176 g (arr176 a B)
lam176 = \ t, tm, var176, lam176, app => lam176 _ _ _ (t tm var176 lam176 app)

app176 : {g:_}->{a:_}->{B:_} -> Tm176 g (arr176 a B) -> Tm176 g a -> Tm176 g B
app176 = \ t, u, tm, var176, lam176, app176 => app176 _ _ _ (t tm var176 lam176 app176) (u tm var176 lam176 app176)

v0176 : {g:_}->{a:_} -> Tm176 (snoc176 g a) a
v0176 = var176 vz176

v1176 : {g:_}->{a:_}-> {B:_}-> Tm176 (snoc176 (snoc176 g a) B) a
v1176 = var176 (vs176 vz176)

v2176 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm176 (snoc176 (snoc176 (snoc176 g a) B) C) a
v2176 = var176 (vs176 (vs176 vz176))

v3176 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm176 (snoc176 (snoc176 (snoc176 (snoc176 g a) B) C) D) a
v3176 = var176 (vs176 (vs176 (vs176 vz176)))

v4176 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm176 (snoc176 (snoc176 (snoc176 (snoc176 (snoc176 g a) B) C) D) E) a
v4176 = var176 (vs176 (vs176 (vs176 (vs176 vz176))))

test176 : {g:_}-> {a:_} -> Tm176 g (arr176 (arr176 a a) (arr176 a a))
test176  = lam176 (lam176 (app176 v1176 (app176 v1176 (app176 v1176 (app176 v1176 (app176 v1176 (app176 v1176 v0176)))))))
Ty177 : Type
Ty177 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty177 : Ty177
empty177 = \ _, empty, _ => empty

arr177 : Ty177 -> Ty177 -> Ty177
arr177 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con177 : Type
Con177 = (Con177 : Type)
 ->(nil  : Con177)
 ->(snoc : Con177 -> Ty177 -> Con177)
 -> Con177

nil177 : Con177
nil177 = \ con, nil177, snoc => nil177

snoc177 : Con177 -> Ty177 -> Con177
snoc177 = \ g, a, con, nil177, snoc177 => snoc177 (g con nil177 snoc177) a

Var177 : Con177 -> Ty177 -> Type
Var177 = \ g, a =>
    (Var177 : Con177 -> Ty177 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var177 (snoc177 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var177 g a -> Var177 (snoc177 g b) a)
 -> Var177 g a

vz177 : {g : _}-> {a : _} -> Var177 (snoc177 g a) a
vz177 = \ var, vz177, vs => vz177 _ _

vs177 : {g : _} -> {B : _} -> {a : _} -> Var177 g a -> Var177 (snoc177 g B) a
vs177 = \ x, var, vz177, vs177 => vs177 _ _ _ (x var vz177 vs177)

Tm177 : Con177 -> Ty177 -> Type
Tm177 = \ g, a =>
    (Tm177    : Con177 -> Ty177 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var177 g a -> Tm177 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm177 (snoc177 g a) B -> Tm177 g (arr177 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm177 g (arr177 a B) -> Tm177 g a -> Tm177 g B)
 -> Tm177 g a

var177 : {g : _} -> {a : _} -> Var177 g a -> Tm177 g a
var177 = \ x, tm, var177, lam, app => var177 _ _ x

lam177 : {g : _} -> {a : _} -> {B : _} -> Tm177 (snoc177 g a) B -> Tm177 g (arr177 a B)
lam177 = \ t, tm, var177, lam177, app => lam177 _ _ _ (t tm var177 lam177 app)

app177 : {g:_}->{a:_}->{B:_} -> Tm177 g (arr177 a B) -> Tm177 g a -> Tm177 g B
app177 = \ t, u, tm, var177, lam177, app177 => app177 _ _ _ (t tm var177 lam177 app177) (u tm var177 lam177 app177)

v0177 : {g:_}->{a:_} -> Tm177 (snoc177 g a) a
v0177 = var177 vz177

v1177 : {g:_}->{a:_}-> {B:_}-> Tm177 (snoc177 (snoc177 g a) B) a
v1177 = var177 (vs177 vz177)

v2177 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm177 (snoc177 (snoc177 (snoc177 g a) B) C) a
v2177 = var177 (vs177 (vs177 vz177))

v3177 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm177 (snoc177 (snoc177 (snoc177 (snoc177 g a) B) C) D) a
v3177 = var177 (vs177 (vs177 (vs177 vz177)))

v4177 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm177 (snoc177 (snoc177 (snoc177 (snoc177 (snoc177 g a) B) C) D) E) a
v4177 = var177 (vs177 (vs177 (vs177 (vs177 vz177))))

test177 : {g:_}-> {a:_} -> Tm177 g (arr177 (arr177 a a) (arr177 a a))
test177  = lam177 (lam177 (app177 v1177 (app177 v1177 (app177 v1177 (app177 v1177 (app177 v1177 (app177 v1177 v0177)))))))
Ty178 : Type
Ty178 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty178 : Ty178
empty178 = \ _, empty, _ => empty

arr178 : Ty178 -> Ty178 -> Ty178
arr178 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con178 : Type
Con178 = (Con178 : Type)
 ->(nil  : Con178)
 ->(snoc : Con178 -> Ty178 -> Con178)
 -> Con178

nil178 : Con178
nil178 = \ con, nil178, snoc => nil178

snoc178 : Con178 -> Ty178 -> Con178
snoc178 = \ g, a, con, nil178, snoc178 => snoc178 (g con nil178 snoc178) a

Var178 : Con178 -> Ty178 -> Type
Var178 = \ g, a =>
    (Var178 : Con178 -> Ty178 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var178 (snoc178 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var178 g a -> Var178 (snoc178 g b) a)
 -> Var178 g a

vz178 : {g : _}-> {a : _} -> Var178 (snoc178 g a) a
vz178 = \ var, vz178, vs => vz178 _ _

vs178 : {g : _} -> {B : _} -> {a : _} -> Var178 g a -> Var178 (snoc178 g B) a
vs178 = \ x, var, vz178, vs178 => vs178 _ _ _ (x var vz178 vs178)

Tm178 : Con178 -> Ty178 -> Type
Tm178 = \ g, a =>
    (Tm178    : Con178 -> Ty178 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var178 g a -> Tm178 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm178 (snoc178 g a) B -> Tm178 g (arr178 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm178 g (arr178 a B) -> Tm178 g a -> Tm178 g B)
 -> Tm178 g a

var178 : {g : _} -> {a : _} -> Var178 g a -> Tm178 g a
var178 = \ x, tm, var178, lam, app => var178 _ _ x

lam178 : {g : _} -> {a : _} -> {B : _} -> Tm178 (snoc178 g a) B -> Tm178 g (arr178 a B)
lam178 = \ t, tm, var178, lam178, app => lam178 _ _ _ (t tm var178 lam178 app)

app178 : {g:_}->{a:_}->{B:_} -> Tm178 g (arr178 a B) -> Tm178 g a -> Tm178 g B
app178 = \ t, u, tm, var178, lam178, app178 => app178 _ _ _ (t tm var178 lam178 app178) (u tm var178 lam178 app178)

v0178 : {g:_}->{a:_} -> Tm178 (snoc178 g a) a
v0178 = var178 vz178

v1178 : {g:_}->{a:_}-> {B:_}-> Tm178 (snoc178 (snoc178 g a) B) a
v1178 = var178 (vs178 vz178)

v2178 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm178 (snoc178 (snoc178 (snoc178 g a) B) C) a
v2178 = var178 (vs178 (vs178 vz178))

v3178 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm178 (snoc178 (snoc178 (snoc178 (snoc178 g a) B) C) D) a
v3178 = var178 (vs178 (vs178 (vs178 vz178)))

v4178 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm178 (snoc178 (snoc178 (snoc178 (snoc178 (snoc178 g a) B) C) D) E) a
v4178 = var178 (vs178 (vs178 (vs178 (vs178 vz178))))

test178 : {g:_}-> {a:_} -> Tm178 g (arr178 (arr178 a a) (arr178 a a))
test178  = lam178 (lam178 (app178 v1178 (app178 v1178 (app178 v1178 (app178 v1178 (app178 v1178 (app178 v1178 v0178)))))))
Ty179 : Type
Ty179 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty179 : Ty179
empty179 = \ _, empty, _ => empty

arr179 : Ty179 -> Ty179 -> Ty179
arr179 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con179 : Type
Con179 = (Con179 : Type)
 ->(nil  : Con179)
 ->(snoc : Con179 -> Ty179 -> Con179)
 -> Con179

nil179 : Con179
nil179 = \ con, nil179, snoc => nil179

snoc179 : Con179 -> Ty179 -> Con179
snoc179 = \ g, a, con, nil179, snoc179 => snoc179 (g con nil179 snoc179) a

Var179 : Con179 -> Ty179 -> Type
Var179 = \ g, a =>
    (Var179 : Con179 -> Ty179 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var179 (snoc179 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var179 g a -> Var179 (snoc179 g b) a)
 -> Var179 g a

vz179 : {g : _}-> {a : _} -> Var179 (snoc179 g a) a
vz179 = \ var, vz179, vs => vz179 _ _

vs179 : {g : _} -> {B : _} -> {a : _} -> Var179 g a -> Var179 (snoc179 g B) a
vs179 = \ x, var, vz179, vs179 => vs179 _ _ _ (x var vz179 vs179)

Tm179 : Con179 -> Ty179 -> Type
Tm179 = \ g, a =>
    (Tm179    : Con179 -> Ty179 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var179 g a -> Tm179 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm179 (snoc179 g a) B -> Tm179 g (arr179 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm179 g (arr179 a B) -> Tm179 g a -> Tm179 g B)
 -> Tm179 g a

var179 : {g : _} -> {a : _} -> Var179 g a -> Tm179 g a
var179 = \ x, tm, var179, lam, app => var179 _ _ x

lam179 : {g : _} -> {a : _} -> {B : _} -> Tm179 (snoc179 g a) B -> Tm179 g (arr179 a B)
lam179 = \ t, tm, var179, lam179, app => lam179 _ _ _ (t tm var179 lam179 app)

app179 : {g:_}->{a:_}->{B:_} -> Tm179 g (arr179 a B) -> Tm179 g a -> Tm179 g B
app179 = \ t, u, tm, var179, lam179, app179 => app179 _ _ _ (t tm var179 lam179 app179) (u tm var179 lam179 app179)

v0179 : {g:_}->{a:_} -> Tm179 (snoc179 g a) a
v0179 = var179 vz179

v1179 : {g:_}->{a:_}-> {B:_}-> Tm179 (snoc179 (snoc179 g a) B) a
v1179 = var179 (vs179 vz179)

v2179 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm179 (snoc179 (snoc179 (snoc179 g a) B) C) a
v2179 = var179 (vs179 (vs179 vz179))

v3179 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm179 (snoc179 (snoc179 (snoc179 (snoc179 g a) B) C) D) a
v3179 = var179 (vs179 (vs179 (vs179 vz179)))

v4179 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm179 (snoc179 (snoc179 (snoc179 (snoc179 (snoc179 g a) B) C) D) E) a
v4179 = var179 (vs179 (vs179 (vs179 (vs179 vz179))))

test179 : {g:_}-> {a:_} -> Tm179 g (arr179 (arr179 a a) (arr179 a a))
test179  = lam179 (lam179 (app179 v1179 (app179 v1179 (app179 v1179 (app179 v1179 (app179 v1179 (app179 v1179 v0179)))))))
Ty180 : Type
Ty180 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty180 : Ty180
empty180 = \ _, empty, _ => empty

arr180 : Ty180 -> Ty180 -> Ty180
arr180 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con180 : Type
Con180 = (Con180 : Type)
 ->(nil  : Con180)
 ->(snoc : Con180 -> Ty180 -> Con180)
 -> Con180

nil180 : Con180
nil180 = \ con, nil180, snoc => nil180

snoc180 : Con180 -> Ty180 -> Con180
snoc180 = \ g, a, con, nil180, snoc180 => snoc180 (g con nil180 snoc180) a

Var180 : Con180 -> Ty180 -> Type
Var180 = \ g, a =>
    (Var180 : Con180 -> Ty180 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var180 (snoc180 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var180 g a -> Var180 (snoc180 g b) a)
 -> Var180 g a

vz180 : {g : _}-> {a : _} -> Var180 (snoc180 g a) a
vz180 = \ var, vz180, vs => vz180 _ _

vs180 : {g : _} -> {B : _} -> {a : _} -> Var180 g a -> Var180 (snoc180 g B) a
vs180 = \ x, var, vz180, vs180 => vs180 _ _ _ (x var vz180 vs180)

Tm180 : Con180 -> Ty180 -> Type
Tm180 = \ g, a =>
    (Tm180    : Con180 -> Ty180 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var180 g a -> Tm180 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm180 (snoc180 g a) B -> Tm180 g (arr180 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm180 g (arr180 a B) -> Tm180 g a -> Tm180 g B)
 -> Tm180 g a

var180 : {g : _} -> {a : _} -> Var180 g a -> Tm180 g a
var180 = \ x, tm, var180, lam, app => var180 _ _ x

lam180 : {g : _} -> {a : _} -> {B : _} -> Tm180 (snoc180 g a) B -> Tm180 g (arr180 a B)
lam180 = \ t, tm, var180, lam180, app => lam180 _ _ _ (t tm var180 lam180 app)

app180 : {g:_}->{a:_}->{B:_} -> Tm180 g (arr180 a B) -> Tm180 g a -> Tm180 g B
app180 = \ t, u, tm, var180, lam180, app180 => app180 _ _ _ (t tm var180 lam180 app180) (u tm var180 lam180 app180)

v0180 : {g:_}->{a:_} -> Tm180 (snoc180 g a) a
v0180 = var180 vz180

v1180 : {g:_}->{a:_}-> {B:_}-> Tm180 (snoc180 (snoc180 g a) B) a
v1180 = var180 (vs180 vz180)

v2180 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm180 (snoc180 (snoc180 (snoc180 g a) B) C) a
v2180 = var180 (vs180 (vs180 vz180))

v3180 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm180 (snoc180 (snoc180 (snoc180 (snoc180 g a) B) C) D) a
v3180 = var180 (vs180 (vs180 (vs180 vz180)))

v4180 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm180 (snoc180 (snoc180 (snoc180 (snoc180 (snoc180 g a) B) C) D) E) a
v4180 = var180 (vs180 (vs180 (vs180 (vs180 vz180))))

test180 : {g:_}-> {a:_} -> Tm180 g (arr180 (arr180 a a) (arr180 a a))
test180  = lam180 (lam180 (app180 v1180 (app180 v1180 (app180 v1180 (app180 v1180 (app180 v1180 (app180 v1180 v0180)))))))
Ty181 : Type
Ty181 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty181 : Ty181
empty181 = \ _, empty, _ => empty

arr181 : Ty181 -> Ty181 -> Ty181
arr181 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con181 : Type
Con181 = (Con181 : Type)
 ->(nil  : Con181)
 ->(snoc : Con181 -> Ty181 -> Con181)
 -> Con181

nil181 : Con181
nil181 = \ con, nil181, snoc => nil181

snoc181 : Con181 -> Ty181 -> Con181
snoc181 = \ g, a, con, nil181, snoc181 => snoc181 (g con nil181 snoc181) a

Var181 : Con181 -> Ty181 -> Type
Var181 = \ g, a =>
    (Var181 : Con181 -> Ty181 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var181 (snoc181 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var181 g a -> Var181 (snoc181 g b) a)
 -> Var181 g a

vz181 : {g : _}-> {a : _} -> Var181 (snoc181 g a) a
vz181 = \ var, vz181, vs => vz181 _ _

vs181 : {g : _} -> {B : _} -> {a : _} -> Var181 g a -> Var181 (snoc181 g B) a
vs181 = \ x, var, vz181, vs181 => vs181 _ _ _ (x var vz181 vs181)

Tm181 : Con181 -> Ty181 -> Type
Tm181 = \ g, a =>
    (Tm181    : Con181 -> Ty181 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var181 g a -> Tm181 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm181 (snoc181 g a) B -> Tm181 g (arr181 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm181 g (arr181 a B) -> Tm181 g a -> Tm181 g B)
 -> Tm181 g a

var181 : {g : _} -> {a : _} -> Var181 g a -> Tm181 g a
var181 = \ x, tm, var181, lam, app => var181 _ _ x

lam181 : {g : _} -> {a : _} -> {B : _} -> Tm181 (snoc181 g a) B -> Tm181 g (arr181 a B)
lam181 = \ t, tm, var181, lam181, app => lam181 _ _ _ (t tm var181 lam181 app)

app181 : {g:_}->{a:_}->{B:_} -> Tm181 g (arr181 a B) -> Tm181 g a -> Tm181 g B
app181 = \ t, u, tm, var181, lam181, app181 => app181 _ _ _ (t tm var181 lam181 app181) (u tm var181 lam181 app181)

v0181 : {g:_}->{a:_} -> Tm181 (snoc181 g a) a
v0181 = var181 vz181

v1181 : {g:_}->{a:_}-> {B:_}-> Tm181 (snoc181 (snoc181 g a) B) a
v1181 = var181 (vs181 vz181)

v2181 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm181 (snoc181 (snoc181 (snoc181 g a) B) C) a
v2181 = var181 (vs181 (vs181 vz181))

v3181 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm181 (snoc181 (snoc181 (snoc181 (snoc181 g a) B) C) D) a
v3181 = var181 (vs181 (vs181 (vs181 vz181)))

v4181 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm181 (snoc181 (snoc181 (snoc181 (snoc181 (snoc181 g a) B) C) D) E) a
v4181 = var181 (vs181 (vs181 (vs181 (vs181 vz181))))

test181 : {g:_}-> {a:_} -> Tm181 g (arr181 (arr181 a a) (arr181 a a))
test181  = lam181 (lam181 (app181 v1181 (app181 v1181 (app181 v1181 (app181 v1181 (app181 v1181 (app181 v1181 v0181)))))))
Ty182 : Type
Ty182 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty182 : Ty182
empty182 = \ _, empty, _ => empty

arr182 : Ty182 -> Ty182 -> Ty182
arr182 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con182 : Type
Con182 = (Con182 : Type)
 ->(nil  : Con182)
 ->(snoc : Con182 -> Ty182 -> Con182)
 -> Con182

nil182 : Con182
nil182 = \ con, nil182, snoc => nil182

snoc182 : Con182 -> Ty182 -> Con182
snoc182 = \ g, a, con, nil182, snoc182 => snoc182 (g con nil182 snoc182) a

Var182 : Con182 -> Ty182 -> Type
Var182 = \ g, a =>
    (Var182 : Con182 -> Ty182 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var182 (snoc182 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var182 g a -> Var182 (snoc182 g b) a)
 -> Var182 g a

vz182 : {g : _}-> {a : _} -> Var182 (snoc182 g a) a
vz182 = \ var, vz182, vs => vz182 _ _

vs182 : {g : _} -> {B : _} -> {a : _} -> Var182 g a -> Var182 (snoc182 g B) a
vs182 = \ x, var, vz182, vs182 => vs182 _ _ _ (x var vz182 vs182)

Tm182 : Con182 -> Ty182 -> Type
Tm182 = \ g, a =>
    (Tm182    : Con182 -> Ty182 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var182 g a -> Tm182 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm182 (snoc182 g a) B -> Tm182 g (arr182 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm182 g (arr182 a B) -> Tm182 g a -> Tm182 g B)
 -> Tm182 g a

var182 : {g : _} -> {a : _} -> Var182 g a -> Tm182 g a
var182 = \ x, tm, var182, lam, app => var182 _ _ x

lam182 : {g : _} -> {a : _} -> {B : _} -> Tm182 (snoc182 g a) B -> Tm182 g (arr182 a B)
lam182 = \ t, tm, var182, lam182, app => lam182 _ _ _ (t tm var182 lam182 app)

app182 : {g:_}->{a:_}->{B:_} -> Tm182 g (arr182 a B) -> Tm182 g a -> Tm182 g B
app182 = \ t, u, tm, var182, lam182, app182 => app182 _ _ _ (t tm var182 lam182 app182) (u tm var182 lam182 app182)

v0182 : {g:_}->{a:_} -> Tm182 (snoc182 g a) a
v0182 = var182 vz182

v1182 : {g:_}->{a:_}-> {B:_}-> Tm182 (snoc182 (snoc182 g a) B) a
v1182 = var182 (vs182 vz182)

v2182 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm182 (snoc182 (snoc182 (snoc182 g a) B) C) a
v2182 = var182 (vs182 (vs182 vz182))

v3182 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm182 (snoc182 (snoc182 (snoc182 (snoc182 g a) B) C) D) a
v3182 = var182 (vs182 (vs182 (vs182 vz182)))

v4182 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm182 (snoc182 (snoc182 (snoc182 (snoc182 (snoc182 g a) B) C) D) E) a
v4182 = var182 (vs182 (vs182 (vs182 (vs182 vz182))))

test182 : {g:_}-> {a:_} -> Tm182 g (arr182 (arr182 a a) (arr182 a a))
test182  = lam182 (lam182 (app182 v1182 (app182 v1182 (app182 v1182 (app182 v1182 (app182 v1182 (app182 v1182 v0182)))))))
Ty183 : Type
Ty183 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty183 : Ty183
empty183 = \ _, empty, _ => empty

arr183 : Ty183 -> Ty183 -> Ty183
arr183 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con183 : Type
Con183 = (Con183 : Type)
 ->(nil  : Con183)
 ->(snoc : Con183 -> Ty183 -> Con183)
 -> Con183

nil183 : Con183
nil183 = \ con, nil183, snoc => nil183

snoc183 : Con183 -> Ty183 -> Con183
snoc183 = \ g, a, con, nil183, snoc183 => snoc183 (g con nil183 snoc183) a

Var183 : Con183 -> Ty183 -> Type
Var183 = \ g, a =>
    (Var183 : Con183 -> Ty183 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var183 (snoc183 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var183 g a -> Var183 (snoc183 g b) a)
 -> Var183 g a

vz183 : {g : _}-> {a : _} -> Var183 (snoc183 g a) a
vz183 = \ var, vz183, vs => vz183 _ _

vs183 : {g : _} -> {B : _} -> {a : _} -> Var183 g a -> Var183 (snoc183 g B) a
vs183 = \ x, var, vz183, vs183 => vs183 _ _ _ (x var vz183 vs183)

Tm183 : Con183 -> Ty183 -> Type
Tm183 = \ g, a =>
    (Tm183    : Con183 -> Ty183 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var183 g a -> Tm183 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm183 (snoc183 g a) B -> Tm183 g (arr183 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm183 g (arr183 a B) -> Tm183 g a -> Tm183 g B)
 -> Tm183 g a

var183 : {g : _} -> {a : _} -> Var183 g a -> Tm183 g a
var183 = \ x, tm, var183, lam, app => var183 _ _ x

lam183 : {g : _} -> {a : _} -> {B : _} -> Tm183 (snoc183 g a) B -> Tm183 g (arr183 a B)
lam183 = \ t, tm, var183, lam183, app => lam183 _ _ _ (t tm var183 lam183 app)

app183 : {g:_}->{a:_}->{B:_} -> Tm183 g (arr183 a B) -> Tm183 g a -> Tm183 g B
app183 = \ t, u, tm, var183, lam183, app183 => app183 _ _ _ (t tm var183 lam183 app183) (u tm var183 lam183 app183)

v0183 : {g:_}->{a:_} -> Tm183 (snoc183 g a) a
v0183 = var183 vz183

v1183 : {g:_}->{a:_}-> {B:_}-> Tm183 (snoc183 (snoc183 g a) B) a
v1183 = var183 (vs183 vz183)

v2183 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm183 (snoc183 (snoc183 (snoc183 g a) B) C) a
v2183 = var183 (vs183 (vs183 vz183))

v3183 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm183 (snoc183 (snoc183 (snoc183 (snoc183 g a) B) C) D) a
v3183 = var183 (vs183 (vs183 (vs183 vz183)))

v4183 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm183 (snoc183 (snoc183 (snoc183 (snoc183 (snoc183 g a) B) C) D) E) a
v4183 = var183 (vs183 (vs183 (vs183 (vs183 vz183))))

test183 : {g:_}-> {a:_} -> Tm183 g (arr183 (arr183 a a) (arr183 a a))
test183  = lam183 (lam183 (app183 v1183 (app183 v1183 (app183 v1183 (app183 v1183 (app183 v1183 (app183 v1183 v0183)))))))
Ty184 : Type
Ty184 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty184 : Ty184
empty184 = \ _, empty, _ => empty

arr184 : Ty184 -> Ty184 -> Ty184
arr184 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con184 : Type
Con184 = (Con184 : Type)
 ->(nil  : Con184)
 ->(snoc : Con184 -> Ty184 -> Con184)
 -> Con184

nil184 : Con184
nil184 = \ con, nil184, snoc => nil184

snoc184 : Con184 -> Ty184 -> Con184
snoc184 = \ g, a, con, nil184, snoc184 => snoc184 (g con nil184 snoc184) a

Var184 : Con184 -> Ty184 -> Type
Var184 = \ g, a =>
    (Var184 : Con184 -> Ty184 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var184 (snoc184 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var184 g a -> Var184 (snoc184 g b) a)
 -> Var184 g a

vz184 : {g : _}-> {a : _} -> Var184 (snoc184 g a) a
vz184 = \ var, vz184, vs => vz184 _ _

vs184 : {g : _} -> {B : _} -> {a : _} -> Var184 g a -> Var184 (snoc184 g B) a
vs184 = \ x, var, vz184, vs184 => vs184 _ _ _ (x var vz184 vs184)

Tm184 : Con184 -> Ty184 -> Type
Tm184 = \ g, a =>
    (Tm184    : Con184 -> Ty184 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var184 g a -> Tm184 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm184 (snoc184 g a) B -> Tm184 g (arr184 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm184 g (arr184 a B) -> Tm184 g a -> Tm184 g B)
 -> Tm184 g a

var184 : {g : _} -> {a : _} -> Var184 g a -> Tm184 g a
var184 = \ x, tm, var184, lam, app => var184 _ _ x

lam184 : {g : _} -> {a : _} -> {B : _} -> Tm184 (snoc184 g a) B -> Tm184 g (arr184 a B)
lam184 = \ t, tm, var184, lam184, app => lam184 _ _ _ (t tm var184 lam184 app)

app184 : {g:_}->{a:_}->{B:_} -> Tm184 g (arr184 a B) -> Tm184 g a -> Tm184 g B
app184 = \ t, u, tm, var184, lam184, app184 => app184 _ _ _ (t tm var184 lam184 app184) (u tm var184 lam184 app184)

v0184 : {g:_}->{a:_} -> Tm184 (snoc184 g a) a
v0184 = var184 vz184

v1184 : {g:_}->{a:_}-> {B:_}-> Tm184 (snoc184 (snoc184 g a) B) a
v1184 = var184 (vs184 vz184)

v2184 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm184 (snoc184 (snoc184 (snoc184 g a) B) C) a
v2184 = var184 (vs184 (vs184 vz184))

v3184 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm184 (snoc184 (snoc184 (snoc184 (snoc184 g a) B) C) D) a
v3184 = var184 (vs184 (vs184 (vs184 vz184)))

v4184 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm184 (snoc184 (snoc184 (snoc184 (snoc184 (snoc184 g a) B) C) D) E) a
v4184 = var184 (vs184 (vs184 (vs184 (vs184 vz184))))

test184 : {g:_}-> {a:_} -> Tm184 g (arr184 (arr184 a a) (arr184 a a))
test184  = lam184 (lam184 (app184 v1184 (app184 v1184 (app184 v1184 (app184 v1184 (app184 v1184 (app184 v1184 v0184)))))))
Ty185 : Type
Ty185 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty185 : Ty185
empty185 = \ _, empty, _ => empty

arr185 : Ty185 -> Ty185 -> Ty185
arr185 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con185 : Type
Con185 = (Con185 : Type)
 ->(nil  : Con185)
 ->(snoc : Con185 -> Ty185 -> Con185)
 -> Con185

nil185 : Con185
nil185 = \ con, nil185, snoc => nil185

snoc185 : Con185 -> Ty185 -> Con185
snoc185 = \ g, a, con, nil185, snoc185 => snoc185 (g con nil185 snoc185) a

Var185 : Con185 -> Ty185 -> Type
Var185 = \ g, a =>
    (Var185 : Con185 -> Ty185 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var185 (snoc185 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var185 g a -> Var185 (snoc185 g b) a)
 -> Var185 g a

vz185 : {g : _}-> {a : _} -> Var185 (snoc185 g a) a
vz185 = \ var, vz185, vs => vz185 _ _

vs185 : {g : _} -> {B : _} -> {a : _} -> Var185 g a -> Var185 (snoc185 g B) a
vs185 = \ x, var, vz185, vs185 => vs185 _ _ _ (x var vz185 vs185)

Tm185 : Con185 -> Ty185 -> Type
Tm185 = \ g, a =>
    (Tm185    : Con185 -> Ty185 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var185 g a -> Tm185 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm185 (snoc185 g a) B -> Tm185 g (arr185 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm185 g (arr185 a B) -> Tm185 g a -> Tm185 g B)
 -> Tm185 g a

var185 : {g : _} -> {a : _} -> Var185 g a -> Tm185 g a
var185 = \ x, tm, var185, lam, app => var185 _ _ x

lam185 : {g : _} -> {a : _} -> {B : _} -> Tm185 (snoc185 g a) B -> Tm185 g (arr185 a B)
lam185 = \ t, tm, var185, lam185, app => lam185 _ _ _ (t tm var185 lam185 app)

app185 : {g:_}->{a:_}->{B:_} -> Tm185 g (arr185 a B) -> Tm185 g a -> Tm185 g B
app185 = \ t, u, tm, var185, lam185, app185 => app185 _ _ _ (t tm var185 lam185 app185) (u tm var185 lam185 app185)

v0185 : {g:_}->{a:_} -> Tm185 (snoc185 g a) a
v0185 = var185 vz185

v1185 : {g:_}->{a:_}-> {B:_}-> Tm185 (snoc185 (snoc185 g a) B) a
v1185 = var185 (vs185 vz185)

v2185 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm185 (snoc185 (snoc185 (snoc185 g a) B) C) a
v2185 = var185 (vs185 (vs185 vz185))

v3185 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm185 (snoc185 (snoc185 (snoc185 (snoc185 g a) B) C) D) a
v3185 = var185 (vs185 (vs185 (vs185 vz185)))

v4185 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm185 (snoc185 (snoc185 (snoc185 (snoc185 (snoc185 g a) B) C) D) E) a
v4185 = var185 (vs185 (vs185 (vs185 (vs185 vz185))))

test185 : {g:_}-> {a:_} -> Tm185 g (arr185 (arr185 a a) (arr185 a a))
test185  = lam185 (lam185 (app185 v1185 (app185 v1185 (app185 v1185 (app185 v1185 (app185 v1185 (app185 v1185 v0185)))))))
Ty186 : Type
Ty186 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty186 : Ty186
empty186 = \ _, empty, _ => empty

arr186 : Ty186 -> Ty186 -> Ty186
arr186 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con186 : Type
Con186 = (Con186 : Type)
 ->(nil  : Con186)
 ->(snoc : Con186 -> Ty186 -> Con186)
 -> Con186

nil186 : Con186
nil186 = \ con, nil186, snoc => nil186

snoc186 : Con186 -> Ty186 -> Con186
snoc186 = \ g, a, con, nil186, snoc186 => snoc186 (g con nil186 snoc186) a

Var186 : Con186 -> Ty186 -> Type
Var186 = \ g, a =>
    (Var186 : Con186 -> Ty186 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var186 (snoc186 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var186 g a -> Var186 (snoc186 g b) a)
 -> Var186 g a

vz186 : {g : _}-> {a : _} -> Var186 (snoc186 g a) a
vz186 = \ var, vz186, vs => vz186 _ _

vs186 : {g : _} -> {B : _} -> {a : _} -> Var186 g a -> Var186 (snoc186 g B) a
vs186 = \ x, var, vz186, vs186 => vs186 _ _ _ (x var vz186 vs186)

Tm186 : Con186 -> Ty186 -> Type
Tm186 = \ g, a =>
    (Tm186    : Con186 -> Ty186 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var186 g a -> Tm186 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm186 (snoc186 g a) B -> Tm186 g (arr186 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm186 g (arr186 a B) -> Tm186 g a -> Tm186 g B)
 -> Tm186 g a

var186 : {g : _} -> {a : _} -> Var186 g a -> Tm186 g a
var186 = \ x, tm, var186, lam, app => var186 _ _ x

lam186 : {g : _} -> {a : _} -> {B : _} -> Tm186 (snoc186 g a) B -> Tm186 g (arr186 a B)
lam186 = \ t, tm, var186, lam186, app => lam186 _ _ _ (t tm var186 lam186 app)

app186 : {g:_}->{a:_}->{B:_} -> Tm186 g (arr186 a B) -> Tm186 g a -> Tm186 g B
app186 = \ t, u, tm, var186, lam186, app186 => app186 _ _ _ (t tm var186 lam186 app186) (u tm var186 lam186 app186)

v0186 : {g:_}->{a:_} -> Tm186 (snoc186 g a) a
v0186 = var186 vz186

v1186 : {g:_}->{a:_}-> {B:_}-> Tm186 (snoc186 (snoc186 g a) B) a
v1186 = var186 (vs186 vz186)

v2186 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm186 (snoc186 (snoc186 (snoc186 g a) B) C) a
v2186 = var186 (vs186 (vs186 vz186))

v3186 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm186 (snoc186 (snoc186 (snoc186 (snoc186 g a) B) C) D) a
v3186 = var186 (vs186 (vs186 (vs186 vz186)))

v4186 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm186 (snoc186 (snoc186 (snoc186 (snoc186 (snoc186 g a) B) C) D) E) a
v4186 = var186 (vs186 (vs186 (vs186 (vs186 vz186))))

test186 : {g:_}-> {a:_} -> Tm186 g (arr186 (arr186 a a) (arr186 a a))
test186  = lam186 (lam186 (app186 v1186 (app186 v1186 (app186 v1186 (app186 v1186 (app186 v1186 (app186 v1186 v0186)))))))
Ty187 : Type
Ty187 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty187 : Ty187
empty187 = \ _, empty, _ => empty

arr187 : Ty187 -> Ty187 -> Ty187
arr187 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con187 : Type
Con187 = (Con187 : Type)
 ->(nil  : Con187)
 ->(snoc : Con187 -> Ty187 -> Con187)
 -> Con187

nil187 : Con187
nil187 = \ con, nil187, snoc => nil187

snoc187 : Con187 -> Ty187 -> Con187
snoc187 = \ g, a, con, nil187, snoc187 => snoc187 (g con nil187 snoc187) a

Var187 : Con187 -> Ty187 -> Type
Var187 = \ g, a =>
    (Var187 : Con187 -> Ty187 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var187 (snoc187 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var187 g a -> Var187 (snoc187 g b) a)
 -> Var187 g a

vz187 : {g : _}-> {a : _} -> Var187 (snoc187 g a) a
vz187 = \ var, vz187, vs => vz187 _ _

vs187 : {g : _} -> {B : _} -> {a : _} -> Var187 g a -> Var187 (snoc187 g B) a
vs187 = \ x, var, vz187, vs187 => vs187 _ _ _ (x var vz187 vs187)

Tm187 : Con187 -> Ty187 -> Type
Tm187 = \ g, a =>
    (Tm187    : Con187 -> Ty187 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var187 g a -> Tm187 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm187 (snoc187 g a) B -> Tm187 g (arr187 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm187 g (arr187 a B) -> Tm187 g a -> Tm187 g B)
 -> Tm187 g a

var187 : {g : _} -> {a : _} -> Var187 g a -> Tm187 g a
var187 = \ x, tm, var187, lam, app => var187 _ _ x

lam187 : {g : _} -> {a : _} -> {B : _} -> Tm187 (snoc187 g a) B -> Tm187 g (arr187 a B)
lam187 = \ t, tm, var187, lam187, app => lam187 _ _ _ (t tm var187 lam187 app)

app187 : {g:_}->{a:_}->{B:_} -> Tm187 g (arr187 a B) -> Tm187 g a -> Tm187 g B
app187 = \ t, u, tm, var187, lam187, app187 => app187 _ _ _ (t tm var187 lam187 app187) (u tm var187 lam187 app187)

v0187 : {g:_}->{a:_} -> Tm187 (snoc187 g a) a
v0187 = var187 vz187

v1187 : {g:_}->{a:_}-> {B:_}-> Tm187 (snoc187 (snoc187 g a) B) a
v1187 = var187 (vs187 vz187)

v2187 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm187 (snoc187 (snoc187 (snoc187 g a) B) C) a
v2187 = var187 (vs187 (vs187 vz187))

v3187 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm187 (snoc187 (snoc187 (snoc187 (snoc187 g a) B) C) D) a
v3187 = var187 (vs187 (vs187 (vs187 vz187)))

v4187 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm187 (snoc187 (snoc187 (snoc187 (snoc187 (snoc187 g a) B) C) D) E) a
v4187 = var187 (vs187 (vs187 (vs187 (vs187 vz187))))

test187 : {g:_}-> {a:_} -> Tm187 g (arr187 (arr187 a a) (arr187 a a))
test187  = lam187 (lam187 (app187 v1187 (app187 v1187 (app187 v1187 (app187 v1187 (app187 v1187 (app187 v1187 v0187)))))))
Ty188 : Type
Ty188 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty188 : Ty188
empty188 = \ _, empty, _ => empty

arr188 : Ty188 -> Ty188 -> Ty188
arr188 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con188 : Type
Con188 = (Con188 : Type)
 ->(nil  : Con188)
 ->(snoc : Con188 -> Ty188 -> Con188)
 -> Con188

nil188 : Con188
nil188 = \ con, nil188, snoc => nil188

snoc188 : Con188 -> Ty188 -> Con188
snoc188 = \ g, a, con, nil188, snoc188 => snoc188 (g con nil188 snoc188) a

Var188 : Con188 -> Ty188 -> Type
Var188 = \ g, a =>
    (Var188 : Con188 -> Ty188 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var188 (snoc188 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var188 g a -> Var188 (snoc188 g b) a)
 -> Var188 g a

vz188 : {g : _}-> {a : _} -> Var188 (snoc188 g a) a
vz188 = \ var, vz188, vs => vz188 _ _

vs188 : {g : _} -> {B : _} -> {a : _} -> Var188 g a -> Var188 (snoc188 g B) a
vs188 = \ x, var, vz188, vs188 => vs188 _ _ _ (x var vz188 vs188)

Tm188 : Con188 -> Ty188 -> Type
Tm188 = \ g, a =>
    (Tm188    : Con188 -> Ty188 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var188 g a -> Tm188 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm188 (snoc188 g a) B -> Tm188 g (arr188 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm188 g (arr188 a B) -> Tm188 g a -> Tm188 g B)
 -> Tm188 g a

var188 : {g : _} -> {a : _} -> Var188 g a -> Tm188 g a
var188 = \ x, tm, var188, lam, app => var188 _ _ x

lam188 : {g : _} -> {a : _} -> {B : _} -> Tm188 (snoc188 g a) B -> Tm188 g (arr188 a B)
lam188 = \ t, tm, var188, lam188, app => lam188 _ _ _ (t tm var188 lam188 app)

app188 : {g:_}->{a:_}->{B:_} -> Tm188 g (arr188 a B) -> Tm188 g a -> Tm188 g B
app188 = \ t, u, tm, var188, lam188, app188 => app188 _ _ _ (t tm var188 lam188 app188) (u tm var188 lam188 app188)

v0188 : {g:_}->{a:_} -> Tm188 (snoc188 g a) a
v0188 = var188 vz188

v1188 : {g:_}->{a:_}-> {B:_}-> Tm188 (snoc188 (snoc188 g a) B) a
v1188 = var188 (vs188 vz188)

v2188 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm188 (snoc188 (snoc188 (snoc188 g a) B) C) a
v2188 = var188 (vs188 (vs188 vz188))

v3188 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm188 (snoc188 (snoc188 (snoc188 (snoc188 g a) B) C) D) a
v3188 = var188 (vs188 (vs188 (vs188 vz188)))

v4188 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm188 (snoc188 (snoc188 (snoc188 (snoc188 (snoc188 g a) B) C) D) E) a
v4188 = var188 (vs188 (vs188 (vs188 (vs188 vz188))))

test188 : {g:_}-> {a:_} -> Tm188 g (arr188 (arr188 a a) (arr188 a a))
test188  = lam188 (lam188 (app188 v1188 (app188 v1188 (app188 v1188 (app188 v1188 (app188 v1188 (app188 v1188 v0188)))))))
Ty189 : Type
Ty189 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty189 : Ty189
empty189 = \ _, empty, _ => empty

arr189 : Ty189 -> Ty189 -> Ty189
arr189 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con189 : Type
Con189 = (Con189 : Type)
 ->(nil  : Con189)
 ->(snoc : Con189 -> Ty189 -> Con189)
 -> Con189

nil189 : Con189
nil189 = \ con, nil189, snoc => nil189

snoc189 : Con189 -> Ty189 -> Con189
snoc189 = \ g, a, con, nil189, snoc189 => snoc189 (g con nil189 snoc189) a

Var189 : Con189 -> Ty189 -> Type
Var189 = \ g, a =>
    (Var189 : Con189 -> Ty189 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var189 (snoc189 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var189 g a -> Var189 (snoc189 g b) a)
 -> Var189 g a

vz189 : {g : _}-> {a : _} -> Var189 (snoc189 g a) a
vz189 = \ var, vz189, vs => vz189 _ _

vs189 : {g : _} -> {B : _} -> {a : _} -> Var189 g a -> Var189 (snoc189 g B) a
vs189 = \ x, var, vz189, vs189 => vs189 _ _ _ (x var vz189 vs189)

Tm189 : Con189 -> Ty189 -> Type
Tm189 = \ g, a =>
    (Tm189    : Con189 -> Ty189 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var189 g a -> Tm189 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm189 (snoc189 g a) B -> Tm189 g (arr189 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm189 g (arr189 a B) -> Tm189 g a -> Tm189 g B)
 -> Tm189 g a

var189 : {g : _} -> {a : _} -> Var189 g a -> Tm189 g a
var189 = \ x, tm, var189, lam, app => var189 _ _ x

lam189 : {g : _} -> {a : _} -> {B : _} -> Tm189 (snoc189 g a) B -> Tm189 g (arr189 a B)
lam189 = \ t, tm, var189, lam189, app => lam189 _ _ _ (t tm var189 lam189 app)

app189 : {g:_}->{a:_}->{B:_} -> Tm189 g (arr189 a B) -> Tm189 g a -> Tm189 g B
app189 = \ t, u, tm, var189, lam189, app189 => app189 _ _ _ (t tm var189 lam189 app189) (u tm var189 lam189 app189)

v0189 : {g:_}->{a:_} -> Tm189 (snoc189 g a) a
v0189 = var189 vz189

v1189 : {g:_}->{a:_}-> {B:_}-> Tm189 (snoc189 (snoc189 g a) B) a
v1189 = var189 (vs189 vz189)

v2189 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm189 (snoc189 (snoc189 (snoc189 g a) B) C) a
v2189 = var189 (vs189 (vs189 vz189))

v3189 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm189 (snoc189 (snoc189 (snoc189 (snoc189 g a) B) C) D) a
v3189 = var189 (vs189 (vs189 (vs189 vz189)))

v4189 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm189 (snoc189 (snoc189 (snoc189 (snoc189 (snoc189 g a) B) C) D) E) a
v4189 = var189 (vs189 (vs189 (vs189 (vs189 vz189))))

test189 : {g:_}-> {a:_} -> Tm189 g (arr189 (arr189 a a) (arr189 a a))
test189  = lam189 (lam189 (app189 v1189 (app189 v1189 (app189 v1189 (app189 v1189 (app189 v1189 (app189 v1189 v0189)))))))
Ty190 : Type
Ty190 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty190 : Ty190
empty190 = \ _, empty, _ => empty

arr190 : Ty190 -> Ty190 -> Ty190
arr190 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con190 : Type
Con190 = (Con190 : Type)
 ->(nil  : Con190)
 ->(snoc : Con190 -> Ty190 -> Con190)
 -> Con190

nil190 : Con190
nil190 = \ con, nil190, snoc => nil190

snoc190 : Con190 -> Ty190 -> Con190
snoc190 = \ g, a, con, nil190, snoc190 => snoc190 (g con nil190 snoc190) a

Var190 : Con190 -> Ty190 -> Type
Var190 = \ g, a =>
    (Var190 : Con190 -> Ty190 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var190 (snoc190 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var190 g a -> Var190 (snoc190 g b) a)
 -> Var190 g a

vz190 : {g : _}-> {a : _} -> Var190 (snoc190 g a) a
vz190 = \ var, vz190, vs => vz190 _ _

vs190 : {g : _} -> {B : _} -> {a : _} -> Var190 g a -> Var190 (snoc190 g B) a
vs190 = \ x, var, vz190, vs190 => vs190 _ _ _ (x var vz190 vs190)

Tm190 : Con190 -> Ty190 -> Type
Tm190 = \ g, a =>
    (Tm190    : Con190 -> Ty190 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var190 g a -> Tm190 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm190 (snoc190 g a) B -> Tm190 g (arr190 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm190 g (arr190 a B) -> Tm190 g a -> Tm190 g B)
 -> Tm190 g a

var190 : {g : _} -> {a : _} -> Var190 g a -> Tm190 g a
var190 = \ x, tm, var190, lam, app => var190 _ _ x

lam190 : {g : _} -> {a : _} -> {B : _} -> Tm190 (snoc190 g a) B -> Tm190 g (arr190 a B)
lam190 = \ t, tm, var190, lam190, app => lam190 _ _ _ (t tm var190 lam190 app)

app190 : {g:_}->{a:_}->{B:_} -> Tm190 g (arr190 a B) -> Tm190 g a -> Tm190 g B
app190 = \ t, u, tm, var190, lam190, app190 => app190 _ _ _ (t tm var190 lam190 app190) (u tm var190 lam190 app190)

v0190 : {g:_}->{a:_} -> Tm190 (snoc190 g a) a
v0190 = var190 vz190

v1190 : {g:_}->{a:_}-> {B:_}-> Tm190 (snoc190 (snoc190 g a) B) a
v1190 = var190 (vs190 vz190)

v2190 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm190 (snoc190 (snoc190 (snoc190 g a) B) C) a
v2190 = var190 (vs190 (vs190 vz190))

v3190 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm190 (snoc190 (snoc190 (snoc190 (snoc190 g a) B) C) D) a
v3190 = var190 (vs190 (vs190 (vs190 vz190)))

v4190 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm190 (snoc190 (snoc190 (snoc190 (snoc190 (snoc190 g a) B) C) D) E) a
v4190 = var190 (vs190 (vs190 (vs190 (vs190 vz190))))

test190 : {g:_}-> {a:_} -> Tm190 g (arr190 (arr190 a a) (arr190 a a))
test190  = lam190 (lam190 (app190 v1190 (app190 v1190 (app190 v1190 (app190 v1190 (app190 v1190 (app190 v1190 v0190)))))))
Ty191 : Type
Ty191 = (Ty    : Type)
   ->(empty : Ty)
   ->(arr   : Ty -> Ty -> Ty)
   -> Ty

empty191 : Ty191
empty191 = \ _, empty, _ => empty

arr191 : Ty191 -> Ty191 -> Ty191
arr191 = \ a, b, ty, empty, arr => arr (a ty empty arr) (b ty empty arr)

Con191 : Type
Con191 = (Con191 : Type)
 ->(nil  : Con191)
 ->(snoc : Con191 -> Ty191 -> Con191)
 -> Con191

nil191 : Con191
nil191 = \ con, nil191, snoc => nil191

snoc191 : Con191 -> Ty191 -> Con191
snoc191 = \ g, a, con, nil191, snoc191 => snoc191 (g con nil191 snoc191) a

Var191 : Con191 -> Ty191 -> Type
Var191 = \ g, a =>
    (Var191 : Con191 -> Ty191 -> Type)
 -> (vz  : (g : _)-> (a : _) -> Var191 (snoc191 g a) a)
 -> (vs  : (g : _)-> (b : _) ->  (a : _) -> Var191 g a -> Var191 (snoc191 g b) a)
 -> Var191 g a

vz191 : {g : _}-> {a : _} -> Var191 (snoc191 g a) a
vz191 = \ var, vz191, vs => vz191 _ _

vs191 : {g : _} -> {B : _} -> {a : _} -> Var191 g a -> Var191 (snoc191 g B) a
vs191 = \ x, var, vz191, vs191 => vs191 _ _ _ (x var vz191 vs191)

Tm191 : Con191 -> Ty191 -> Type
Tm191 = \ g, a =>
    (Tm191    : Con191 -> Ty191 -> Type)
 -> (var   : (g : _) -> (a : _) -> Var191 g a -> Tm191 g a)
 -> (lam   : (g : _) -> (a : _) -> (B : _) -> Tm191 (snoc191 g a) B -> Tm191 g (arr191 a B))
 -> (app   : (g : _) -> (a : _) -> (B : _) -> Tm191 g (arr191 a B) -> Tm191 g a -> Tm191 g B)
 -> Tm191 g a

var191 : {g : _} -> {a : _} -> Var191 g a -> Tm191 g a
var191 = \ x, tm, var191, lam, app => var191 _ _ x

lam191 : {g : _} -> {a : _} -> {B : _} -> Tm191 (snoc191 g a) B -> Tm191 g (arr191 a B)
lam191 = \ t, tm, var191, lam191, app => lam191 _ _ _ (t tm var191 lam191 app)

app191 : {g:_}->{a:_}->{B:_} -> Tm191 g (arr191 a B) -> Tm191 g a -> Tm191 g B
app191 = \ t, u, tm, var191, lam191, app191 => app191 _ _ _ (t tm var191 lam191 app191) (u tm var191 lam191 app191)

v0191 : {g:_}->{a:_} -> Tm191 (snoc191 g a) a
v0191 = var191 vz191

v1191 : {g:_}->{a:_}-> {B:_}-> Tm191 (snoc191 (snoc191 g a) B) a
v1191 = var191 (vs191 vz191)

v2191 : {g:_}-> {a:_}-> {B:_}-> {C:_} -> Tm191 (snoc191 (snoc191 (snoc191 g a) B) C) a
v2191 = var191 (vs191 (vs191 vz191))

v3191 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_} -> Tm191 (snoc191 (snoc191 (snoc191 (snoc191 g a) B) C) D) a
v3191 = var191 (vs191 (vs191 (vs191 vz191)))

v4191 : {g:_}-> {a:_}-> {B:_}-> {C:_}-> {D:_}-> {E:_}-> Tm191 (snoc191 (snoc191 (snoc191 (snoc191 (snoc191 g a) B) C) D) E) a
v4191 = var191 (vs191 (vs191 (vs191 (vs191 vz191))))

test191 : {g:_}-> {a:_} -> Tm191 g (arr191 (arr191 a a) (arr191 a a))
test191  = lam191 (lam191 (app191 v1191 (app191 v1191 (app191 v1191 (app191 v1191 (app191 v1191 (app191 v1191 v0191)))))))

ext: idr

max_stars_repo_name: Kha/smalltt

max_issues_repo_name: Kha/smalltt

max_forks_repo_name: Kha/smalltt