From 5c95e5c38649f6cb361533a913b6757ce233ead3 Mon Sep 17 00:00:00 2001
From: Wilf Offord <111688351+wilfofford@users.noreply.github.com>
Date: Fri, 15 Aug 2025 10:18:16 +0100
Subject: [PATCH 01/30] [eckmann-hilton] examples using the general scheme

---
 .../higher-eh/eh-3-0.catt                     | 245 ++++++++++++++++
 .../higher-eh/eh430.catt                      | 276 ++++++++++++++++++
 .../higher-eh/ehbasecases.catt                | 185 ++++++++++++
 examples/horizontalinverses.catt              |  15 +
 4 files changed, 721 insertions(+)
 create mode 100644 examples/eckmann-hilton-versions/higher-eh/eh-3-0.catt
 create mode 100644 examples/eckmann-hilton-versions/higher-eh/eh430.catt
 create mode 100644 examples/eckmann-hilton-versions/higher-eh/ehbasecases.catt
 create mode 100644 examples/horizontalinverses.catt

diff --git a/examples/eckmann-hilton-versions/higher-eh/eh-3-0.catt b/examples/eckmann-hilton-versions/higher-eh/eh-3-0.catt
new file mode 100644
index 00000000..34490878
--- /dev/null
+++ b/examples/eckmann-hilton-versions/higher-eh/eh-3-0.catt
@@ -0,0 +1,245 @@
+let 1paddedL (x : *) (y : *)
+    	     (f : x -> x) (g : x -> y)
+	     = comp f g
+
+coh 2padL (x(f)y) : f -> 1paddedL (id x) f
+
+let 1paddedU (x : *)
+    	     (f : x -> x) (g : x -> x)
+    	     = comp f g
+
+coh 2padU (x) : id x -> 1paddedU (id x) (id x)
+
+coh bias (x) : 2padU x -> 2padL (id x)
+
+coh Ibias (x) : I (2padU x) -> I (2padL (id x))
+
+let 2paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : id x -> id x) (b : f -> g)
+	     = comp (2padL f) (1paddedL [a] [b]) (I (2padL g))
+
+coh 3padL (x(f(a)g)y) : a -> 2paddedL (id (id x)) a
+
+let 2paddedU (x : *)
+    	     (a : id x -> id x) (b : id x -> id x)
+    	     = comp (2padU x) (1paddedU [a] [b]) (I (2padU x))
+
+coh 3padU (x) : id (id x) -> 2paddedU (id (id x)) (id (id x))
+
+let 3paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : f -> g) (b : f -> g)
+	     (p : id (id x) -> id (id x)) (q : a -> b)
+	     = comp (3padL a) (2paddedL [p] [q]) (I (3padL b))
+	     
+coh 4padL (x(f(a(p)b)g)y) : p -> 3paddedL (id (id (id x))) p
+
+
+let 3paddedU (x : *)
+    	     (p : id (id x) -> id (id x)) (q : (id (id x)) -> (id (id x)))
+    	     = comp (3padU x) (2paddedU [p] [q]) (I (3padU x))
+
+coh 4padU (x) : id (id (id x)) -> 3paddedU (id (id (id x))) (id (id (id x)))
+
+let 4paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : f -> g) (b : f -> g)
+	     (p : a -> b) (q : a -> b)
+	     (m : id (id (id x)) -> id (id (id x))) (n : p -> q)
+	     = comp (4padL p) (3paddedL [m] [n]) (I (4padL q))
+
+coh 5padL (x(f(a(p(m)q)b)g)y) : m -> 4paddedL (id (id (id (id x)))) m
+
+let 4paddedU (x : *)
+    	     (m : id (id (id x)) -> id (id (id x))) (n : id (id (id x)) -> id (id (id x)))
+	     = comp (4padU x) (3paddedU [m] [n]) (I (4padU x))
+
+coh 5padU (x) : id (id (id (id x))) -> 4paddedU (id (id (id (id x)))) (id (id (id (id x))))
+
+
+coh focus-33-to-middle2 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6) :
+    comp (comp f1 f2 f3) (comp f4 f5 f6) -> comp f1 f2 (comp f3 f4) f5 f6
+
+coh factor3padL (x) : 3padL (id (id x)) -> comp (3padU x) (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x])
+
+coh unfactor3padU (x) : comp (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x])
+    		      	     (I (3padL (id (id x))))
+			     -> I (3padU x)
+
+coh burger (x(f(a)g)y(h)z(j(b)k)w) : comp f h j -> comp g h k
+
+let nat-of-id-WRT-bias (x : *) (y : *) (z : *) (w : *)
+    		       (f1 : x -> y) (f2 : x -> y) (g1 : y -> z) (g2 : y -> z) (h1 : z -> w) (h2 : z -> w)
+		       (a : f1 -> f2) (b : g1 -> g2) (c : h1 -> h2) 
+		       = burger a [b] c
+
+let middlestep1 (x : *) = comp [factor3padL x] (2paddedL [id (id (id x))] [id (id (id x))]) (I (3padL (id (id x))))
+
+coh focus-first2-to-middle2 (x0(f1)x1(f2)x2(f3)x3(f4)x4) : comp (comp f1 f2) f3 f4 -> comp f1 (comp f2 f3) f4
+
+let middlestep2 (x : *) 
+    		= focus-first2-to-middle2 (3padU x)
+		  			  (burger (bias x) (comp [id (id x)] [id (id x)]) (Ibias x))
+					  (2paddedL [id (id (id x))] [id (id (id x))])
+					  (I (3padL (id (id x))))
+
+let middlestep3 (x : *)
+    		= comp (3padU x) [nat-of-id-WRT-bias (bias x) (comp [[id (id (id x))]] [[id (id (id x))]]) (Ibias x)]  (I (3padL (id (id x))))
+
+coh focus-middle2-to-last2 (x0(f1)x1(f2)x2(f3)x3(f4)x4) : comp f1 (comp f2 f3) f4 -> comp f1 f2 (comp f3 f4)
+
+let middlestep4 (x : *)
+    		= focus-middle2-to-last2 (3padU x)
+		  			 (2paddedU [id (id (id x))] [id (id (id x))])
+		  		 	 (burger (bias x) (comp [id (id x)] [id (id x)]) (Ibias x))
+					 (I (3padL (id (id x))))
+
+let middlestep5 (x : *)
+    		= comp (3padU x) (2paddedU [id (id (id x))] [id (id (id x))]) [unfactor3padU x]
+
+let middle (x : *)
+    	   = comp (middlestep1 x)
+	     	  (middlestep2 x)
+		  (middlestep3 x)
+		  (middlestep4 x)
+		  (middlestep5 x)
+		  (I (op { 1 } (middlestep5 x)))
+		  (I (op { 1 } (middlestep4 x)))
+		  (I (op { 1 } (middlestep3 x)))
+		  (I (op { 1 } (middlestep2 x)))
+		  (I (op { 1 } (middlestep1 x)))
+
+coh middlereplace (x) : comp (I (4padL (id (id (id x))))) (op { 1 } (4padL (id (id (id x))))) -> middle x
+
+let step1 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = comp [5padL m] [op { 1 } (5padL n)]
+
+let step2 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = focus-33-to-middle2 (4padL (id (id (id x))))
+	    		    	(3paddedL [id (id (id (id x)))] [m])
+			    	(I (4padL (id (id (id x)))))
+			   	(op { 1 } (4padL (id (id (id x)))))
+			    	(op { 1 } (3paddedL [id (id (id (id x)))] [n]))
+			    	(op { 1 } (I (4padL (id (id (id x))))))
+let step3 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = comp  (4padL (id (id (id x))))
+	    	  (3paddedL [id (id (id (id x)))] [m])
+		  [middlereplace x]
+		  (op { 1 } (3paddedL [id (id (id (id x)))] [n]))
+		  (op { 1 } (I (4padL (id (id (id x))))))
+		  
+coh focus-2-3-and-12-13 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6(f7)x7(f8)x8(f9)x9(f10)x10(f11)x11(f12)x12(f13)x13(f14)x14)
+    : comp f1 f2 (comp f3 f4 f5 f6 f7 f8 f9 f10 f11 f12) f13 f14 -> comp f1 (comp f2 f3) f4 f5 f6 f7 f8 f9 f10 f11 (comp f12 f13) f14
+
+let step4 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = focus-2-3-and-12-13
+	  (4padL (id (id (id x))))
+	  (3paddedL [id (id (id (id x)))] [m])
+	  (middlestep1 x)
+	  (middlestep2 x)
+	  (middlestep3 x)
+	  (middlestep4 x)
+	  (middlestep5 x)
+	  (I (op { 1 } (middlestep5 x)))
+	  (I (op { 1 } (middlestep4 x)))
+	  (I (op { 1 } (middlestep3 x)))
+	  (I (op { 1 } (middlestep2 x)))
+	  (I (op { 1 } (middlestep1 x)))
+	  (op { 1 } (3paddedL [id (id (id (id x)))] [n]))
+	  (op { 1 } (I (4padL (id (id (id x))))))
+
+coh sandwisk (x(f)y(g(a)h)z(k)w) : comp f g k -> comp f h k
+
+let nat-middletoleft (x : *) (y : *) (z : *) (w : *)
+    			(f1 : x -> y) (f2 : x -> y) (g1 : y -> z) (g2 : y -> z) 
+			(a : f1 -> f2) (b : g1 -> g2) (h : z -> w)
+			= sandwisk [a] b h
+
+let nat-factoring-WRT-m  (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  = nat-middletoleft (factor3padL x) (2paddedL [[id (id (id (id x)))]] [[m]] ) (I (3padL (id (id x))))
+
+let nat-factoring-WRT-n  (x : *)
+    	  (n : id (id (id x)) -> id (id (id x)))
+	  = I (nat-middletoleft (I (op { 1 } (factor3padL x))) (op { 1 } (2paddedL [[id (id (id (id x)))]] [[n]])) (I (op { 1 } (3padL (id (id x))))))
+	  
+let step5 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = comp
+	  (4padL (id (id (id x))))
+	  [nat-factoring-WRT-m m]
+	  (middlestep2 x)
+	  (middlestep3 x)
+	  (middlestep4 x)
+	  (middlestep5 x)
+	  (I (op { 1 } (middlestep5 x)))
+	  (I (op { 1 } (middlestep4 x)))
+	  (I (op { 1 } (middlestep3 x)))
+	  (I (op { 1 } (middlestep2 x)))
+	  [nat-factoring-WRT-n n]
+	  (op { 1 } (I (4padL (id (id (id x))))))
+
+coh focus-3-4-and-11-12 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6(f7)x7(f8)x8(f9)x9(f10)x10(f11)x11(f12)x12(f13)x13(f14)x14)
+    : comp f1 (comp f2 f3) f4 f5 f6 f7 f8 f9 f10 f11 (comp f12 f13) f14 -> comp f1 f2 (comp f3 f4) f5 f6 f7 f8 f9 f10 (comp f11 f12) f13 f14
+
+let step6 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = focus-3-4-and-11-12
+	  (4padL (id (id (id x))))
+	  (middlestep1 x)
+	  (comp (comp (3padU x) (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x])) [2paddedL [[id (id (id (id x)))]] [[m]]] (I (3padL (id (id x)))))
+	  (middlestep2 x)
+	  (middlestep3 x)
+	  (middlestep4 x)
+	  (middlestep5 x)
+	  (I (op { 1 } (middlestep5 x)))
+	  (I (op { 1 } (middlestep4 x)))
+	  (I (op { 1 } (middlestep3 x)))
+	  (I (op { 1 } (middlestep2 x)))
+	  (comp (op { 1 } (comp (3padU x) (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x]))) [op { 1 } (2paddedL [[id (id (id (id x)))]] [[n]])] (I (op { 1 } (3padL (id (id x))))))
+	  (I (op { 1 } (middlestep1 x)))
+	  (op { 1 } (I (4padL (id (id (id x))))))
+
+let nat-assoc-WRT-m (x : *)
+    		    (m : id (id (id x)) -> id (id (id x)))
+		    = focus-first2-to-middle2 (3padU x) (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x]) [2paddedL [[id (id (id (id x)))]] [[m]]] (I (3padL (id (id x))))
+
+coh focus-middle2-to-first2 (x0(f1)x1(f2)x2(f3)x3(f4)x4) : comp f1 (comp f2 f3) f4 -> comp (comp f1 f2) f3 f4
+
+let nat-assoc-WRT-n (x : *)
+    		    (n : id (id (id x)) -> id (id (id x)))
+		    = I (focus-middle2-to-first2 (3padU x) (op { 1 } (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x])) [op { 1 } (2paddedL [[id (id (id (id x)))]] [[n]])] (I (op { 1 } (3padL (id (id x))))))
+
+let step7 (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = comp
+	  (4padL (id (id (id x))))
+	  (middlestep1 x)
+	  [nat-assoc-WRT-m m]
+	  (middlestep3 x)
+	  (middlestep4 x)
+	  (middlestep5 x)
+	  (I (op { 1 } (middlestep5 x)))
+	  (I (op { 1 } (middlestep4 x)))
+	  (I (op { 1 } (middlestep3 x)))
+	  [nat-assoc-WRT-n n]
+	  (I (op { 1 } (middlestep1 x)))
+	  (op { 1 } (I (4padL (id (id (id x))))))
+
+let test  (x : *)
+    	  (m : id (id (id x)) -> id (id (id x)))
+	  (n : id (id (id x)) -> id (id (id x)))
+	  = comp (step1 m n) (step2 m n) (step3 m n) (step4 m n) (step5 m n) (step6 m n) (step7 m n)
+
diff --git a/examples/eckmann-hilton-versions/higher-eh/eh430.catt b/examples/eckmann-hilton-versions/higher-eh/eh430.catt
new file mode 100644
index 00000000..0cd73335
--- /dev/null
+++ b/examples/eckmann-hilton-versions/higher-eh/eh430.catt
@@ -0,0 +1,276 @@
+let 1paddedL (x : *) (y : *)
+    	     (f : x -> x) (g : x -> y)
+	     = comp f g
+
+coh 2padL (x(f)y) : f -> 1paddedL (id x) f
+
+let 1paddedU (x : *)
+    	     (f : x -> x) (g : x -> x)
+    	     = comp f g
+
+coh 2padU (x) : id x -> 1paddedU (id x) (id x)
+
+coh bias (x) : 2padU x -> 2padL (id x)
+
+coh Ibias (x) : I (2padU x) -> I (2padL (id x))
+
+let 2paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : id x -> id x) (b : f -> g)
+	     = comp (2padL f) (1paddedL [a] [b]) (I (2padL g))
+
+coh 3padL (x(f(a)g)y) : a -> 2paddedL (id (id x)) a
+
+let 2paddedU (x : *)
+    	     (a : id x -> id x) (b : id x -> id x)
+    	     = comp (2padU x) (1paddedU [a] [b]) (I (2padU x))
+
+coh 3padU (x) : id (id x) -> 2paddedU (id (id x)) (id (id x))
+
+let 3paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : f -> g) (b : f -> g)
+	     (p : id (id x) -> id (id x)) (q : a -> b)
+	     = comp (3padL a) (2paddedL [p] [q]) (I (3padL b))
+	     
+coh 4padL (x(f(a(p)b)g)y) : p -> 3paddedL (id (id (id x))) p
+
+
+let 3paddedU (x : *)
+    	     (p : id (id x) -> id (id x)) (q : (id (id x)) -> (id (id x)))
+    	     = comp (3padU x) (2paddedU [p] [q]) (I (3padU x))
+
+coh 4padU (x) : id (id (id x)) -> 3paddedU (id (id (id x))) (id (id (id x)))
+
+let 4paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : f -> g) (b : f -> g)
+	     (p : a -> b) (q : a -> b)
+	     (m : id (id (id x)) -> id (id (id x))) (n : p -> q)
+	     = comp (4padL p) (3paddedL [m] [n]) (I (4padL q))
+
+coh 5padL (x(f(a(p(m)q)b)g)y) : m -> 4paddedL (id (id (id (id x)))) m
+
+let 4paddedU (x : *)
+    	     (m : id (id (id x)) -> id (id (id x))) (n : id (id (id x)) -> id (id (id x)))
+	     = comp (4padU x) (3paddedU [m] [n]) (I (4padU x))
+
+coh 5padU (x) : id (id (id (id x))) -> 4paddedU (id (id (id (id x)))) (id (id (id (id x))))
+
+
+let 5paddedL (x : *) (y : *)
+    	     (f : x -> y) (g : x -> y)
+	     (a : f -> g) (b : f -> g)
+	     (p : a -> b) (q : a -> b)
+	     (m : p -> q) (n : p -> q)
+	     (A : (id (id (id (id x)))) -> id (id (id (id x)))) (B : m -> n)
+	     = comp (5padL m) (4paddedL [A] [B]) (I (5padL n))
+coh 6padL (x(f(a(p(m(A)n)q)b)g)y) : A -> 5paddedL (id (id (id (id (id x))))) A
+
+let 5paddedU (x : *)
+    	     (A : (id (id (id (id x)))) -> id (id (id (id x)))) (B : (id (id (id (id x)))) -> id (id (id (id x))))
+	     = comp (5padU x) (4paddedU [A] [B]) (I (5padU x))
+
+coh 6padU (x) : id (id (id (id (id x)))) -> 5paddedU (id (id (id (id (id x))))) (id (id (id (id (id x)))))
+
+
+
+coh factor3padL (x) : 3padL (id (id x)) -> comp (3padU x) (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x])
+
+coh unfactor3padU (x) : comp (comp [bias x] (comp [id (id x)] [id (id x)]) [Ibias x])
+    		      	     (I (3padL (id (id x))))
+			     -> I (3padU x)
+
+coh burger (x(f(a)g)y(h)z(j(b)k)w) : comp f h j -> comp g h k
+
+let nat-of-id-WRT-bias (x : *) (y : *) (z : *) (w : *)
+    		       (f1 : x -> y) (f2 : x -> y) (g1 : y -> z) (g2 : y -> z) (h1 : z -> w) (h2 : z -> w)
+		       (a : f1 -> f2) (b : g1 -> g2) (c : h1 -> h2) 
+		       = burger a [b] c
+
+
+
+
+
+coh focus-first2-to-middle2 (x0(f1)x1(f2)x2(f3)x3(f4)x4) : comp (comp f1 f2) f3 f4 -> comp f1 (comp f2 f3) f4
+
+coh focus-middle2-to-last2 (x0(f1)x1(f2)x2(f3)x3(f4)x4) : comp f1 (comp f2 f3) f4 -> comp f1 f2 (comp f3 f4)
+
+let trapeziumcomposite (B0 : *) (B1 : *) (B2 : *) (B3 : *) (T0 : *) (T1 : *)
+    		       (b1 : B0 -> B1) (b2 : B1 -> B2) (b3 : B2 -> B3) (sL : B0 -> T0) (sR : T1 -> B3) (m1 : T0 -> B1) (m2 : T1 -> B2) (t : T0 -> T1)
+		       (fL : b1 -> comp sL m1) (fM : comp m1 b2 -> comp t m2) (fR : comp m2 b3 -> sR)
+		       = comp
+		       (comp (comp [fL] b2 b3)
+		       (focus-first2-to-middle2 sL m1 b2 b3))
+		       (comp sL [fM] b3)
+		       (comp (focus-middle2-to-last2 sL t m2 b3)
+		       (comp sL t [fR]))
+
+
+
+
+let 3paddedLto3paddedU (x : *) (p : id (id x) -> id (id x)) (q : id (id x) -> id (id x))
+    	       : 3paddedL p q -> 3paddedU p q
+    	       = trapeziumcomposite (factor3padL x) (nat-of-id-WRT-bias (bias x) (comp [[p]] [[q]]) (Ibias x)) (unfactor3padU x)
+
+let 3paddedLto3paddedU_nat  (x : *) (p0 : id (id x) -> id (id x)) (p1 : id (id x) -> id (id x)) (m : p0 -> p1) (q0 : id (id x) -> id (id x)) (q1 : id (id x) -> id (id x)) (n : q0 -> q1) = I (3paddedLto3paddedU [m] [n])
+
+let 3paddedUto3paddedR (x : *) (p : id (id x) -> id (id x)) (q : id (id x) -> id (id x))
+    		       : 3paddedU p q -> (op { 1 } (3paddedL q p))
+    		       = op { 1 } (I (3paddedLto3paddedU q p))
+
+let 3paddedUto3paddedR_nat  (x : *) (p0 : id (id x) -> id (id x)) (p1 : id (id x) -> id (id x)) (m : p0 -> p1) (q0 : id (id x) -> id (id x)) (q1 : id (id x) -> id (id x)) (n : q0 -> q1) = 3paddedUto3paddedR [m] [n]
+
+
+
+
+
+let middlehalf (x : *)
+    	       = 3paddedLto3paddedU (id (id (id x))) (id (id (id x)))
+
+let middle (x : *) = comp (middlehalf x) (op { 1 } (I (middlehalf x)))
+
+coh middlereplace (x) : comp (I (4padL (id (id (id x))))) (op { 1 } (4padL (id (id (id x))))) -> middle x
+
+
+
+
+
+
+
+coh whiskering_interchange (x(f)y(g(a)h(b)i)z(k)w) : comp (comp f [a] k) (comp f [b] k) -> comp f [comp a b] k
+
+coh whiskering_interchange+ (x(f)y(g(a(p)b(q)c)h)z(k)w) : comp (comp f [[p]] k) (comp f [[q]] k) -> comp f [[comp p q]] k
+
+let interchange1 (x : *) (m : id (id (id x)) -> id (id (id x)))  (n : id (id (id x)) -> id (id (id x)))
+    		 = whiskering_interchange (3padU x) (2paddedU [[id (id (id (id x)))]] [[m]]) (2paddedU [[n]] [[id (id (id (id x)))]]) (I (3padU x))
+
+let interchange2 (x : *) (m : id (id (id x)) -> id (id (id x)))  (n : id (id (id x)) -> id (id (id x)))
+    		 = comp (3padU x) [[whiskering_interchange+ (2padU x) (comp [[[id (id (id (id x)))]]] [[[m]]]) (comp [[[n]]] [[[id (id (id (id x)))]]]) (I (2padU x))]] (I (3padU x))
+
+coh interchange_inside (x(f(a(p(A)q)b)g)y(h(c(r(B)s)d)i)z) : comp (comp [[[id p]]] [[[B]]]) (comp [[[A]]] [[[id s]]]) -> comp [[[A]]] [[[B]]]
+
+let interchange3 (x : *) (m : id (id (id x)) -> id (id (id x)))  (n : id (id (id x)) -> id (id (id x)))
+    		 = comp (3padU x) [[comp (2padU x) [[[interchange_inside n m]]] (I (2padU x))]] (I (3padU x))
+
+let interchange (x : *) (m : id (id (id x)) -> id (id (id x))) (n : id (id (id x)) -> id (id (id x)))
+    		 = comp (interchange1 m n) (interchange2 m n) (interchange3 m n)
+
+
+
+
+
+coh tidyl (x) : comp (4padL (id (id (id x)))) (3paddedLto3paddedU (id (id (id x))) (id (id (id x)))) -> 4padU x
+
+coh tidyr (x) : comp (3paddedUto3paddedR (id (id (id x))) (id (id (id x)))) (I (op { 1 } (4padL (id (id (id x)))))) -> I (4padU x)
+
+
+
+
+
+coh focus-33-to-middle2 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6) :
+    comp (comp f1 f2 f3) (comp f4 f5 f6) -> comp f1 f2 (comp f3 f4) f5 f6
+
+coh focus-middle2-to-1221 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6) : comp f1 f2 (comp f3 f4) f5 f6 -> comp f1 (comp f2 f3) (comp f4 f5) f6
+
+coh focus-1221-to-222 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6) : comp f1 (comp f2 f3) (comp f4 f5) f6 -> comp (comp f1 f2) (comp f3 f4) (comp f5 f6)
+
+let totalshape (A0 : *) (B0 : *) (C0 : *)
+    	       	     	(B1 : *) 
+    	       (A1 : *)	      	 (C1 : *)
+			(B2 : *)
+	       (A2 : *) (B3 : *) (C2 : *)
+
+	       (m : A0 -> A1) (n : A1 -> A2)
+	       (lpad : A0 -> B0) (lwhiskm : B0 -> B1) (ilpad : B1 -> A1) (rpad : A1 -> B2) (rwhiskn : B2 -> B3) (irpad : B3 -> A2)
+	       (lmoves_outer : B0 -> C0) (lmoves_inner : B1 -> C1) (rmoves_inner : C1 -> B2) (rmoves_outer : C2 -> B3)
+	       (uwhiskm : C0 -> C1) (uwhiskn : C1 -> C2) (mn : C0 -> C2) (upad : A0 -> C0) (iupad : C2 -> A2)
+
+	       (lpadm : m -> comp lpad lwhiskm ilpad) (rpadn : n -> comp rpad rwhiskn irpad)
+	       (middlereplace : comp ilpad rpad -> comp lmoves_inner rmoves_inner)
+	       (lnat : comp lwhiskm lmoves_inner -> comp lmoves_outer uwhiskm)
+	       (rnat : comp rmoves_inner rwhiskn -> comp uwhiskn rmoves_outer)
+	       (interchange : comp uwhiskm uwhiskn -> mn) (tidyl : comp lpad lmoves_outer -> upad) (tidyr : comp rmoves_outer irpad -> iupad)
+
+	       = comp
+	       (comp [lpadm] [rpadn])
+	       (focus-33-to-middle2 _ _ _ _ _ _)
+	       (comp _ _ [middlereplace] _ _)
+	       (focus-middle2-to-1221 _ _ _ _ _ _)
+	       (comp _ [lnat] [rnat] _)
+	       (focus-1221-to-222 _ _ _ _ _ _)
+	       (comp [tidyl] [interchange] [tidyr])
+
+
+
+let eh430 (x : *) (m : id (id (id x)) -> id (id (id x))) (n : id (id (id x)) -> id (id (id x)))
+    	  : comp m n -> 4paddedU n m
+    	  = totalshape
+	  (5padL m) (op { 1 } (5padL n))
+	  (middlereplace x)
+	  (3paddedLto3paddedU_nat (id (id (id (id x)))) m)
+	  (3paddedUto3paddedR_nat n (id (id (id (id x)))))
+	  (interchange m n)
+	  (tidyl x) (tidyr x)
+
+coh factor4padL (x) : 4padL (id (id (id x))) -> comp (4padU x) (I (3paddedLto3paddedU (id (id (id x))) (id (id (id x)))))
+
+let 3paddedUto3paddedL (x : *) (a : id (id x) -> id (id x)) (b : id (id x) -> id (id x)) = I (3paddedLto3paddedU a b)
+
+let 3paddedUto3paddedL_nat (x : *) (a0 : id (id x) -> id (id x)) (a1 : id (id x) -> id (id x)) (a : a0 -> a1) (b0 : id (id x) -> id (id x)) (b1 : id (id x) -> id (id x)) (b : b0 -> b1) = 3paddedUto3paddedL [a] [b]
+
+coh unfactor4padU (x) : comp (3paddedUto3paddedL (id (id (id x))) (id (id (id x)))) (I (4padL (id (id (id x))))) -> I (4padU x) 
+
+let 4paddedLto4paddedU (x : *) (a : (id (id (id x))) -> (id (id (id x))))
+    : 4paddedL (id (id (id (id x)))) a -> 4paddedU (id (id (id (id x)))) a
+    = trapeziumcomposite (factor4padL x) (3paddedUto3paddedL_nat (id (id (id (id x)))) a) (unfactor4padU x)
+
+let 4paddedLto4paddedU_nat (x : *) (a0 : (id (id (id x))) -> (id (id (id x)))) (a1 : (id (id (id x))) -> (id (id (id x)))) (a : a0 -> a1)
+
+    = 4paddedLto4paddedU [a]
+
+
+let 4paddedUto4paddedR (x : *) (a : (id (id (id x))) -> (id (id (id x))))
+    = I (op { 1 } (4paddedLto4paddedU a))
+
+let 4paddedUto4paddedR_nat (x : *) (a0 : (id (id (id x))) -> (id (id (id x)))) (a1 : (id (id (id x))) -> (id (id (id x)))) (a : a0 -> a1)
+
+    = 4paddedUto4paddedR [a]
+
+coh middlereplace+ (x) : comp (I (5padL (id (id (id (id x)))))) (op { 1 } (5padL (id (id (id (id x)))))) -> comp (4paddedLto4paddedU (id (id (id (id x))))) (4paddedUto4paddedR (id (id (id (id x)))))
+
+
+coh whiskering_interchange++ (x(f)y(g(a(p(A)q(B)r)b)h)z(k)w) : comp (comp f [[[A]]] k) (comp f [[[B]]] k) -> comp f [[[comp A B]]] k
+
+let interchange+1 (x : *) (a : id (id (id (id x))) -> id (id (id (id x))))  (b : id (id (id (id x))) -> id (id (id (id x))))
+    = whiskering_interchange (4padU x) (3paddedU [[id (id (id (id (id x))))]] [[a]]) (3paddedU [[b]] [[id (id (id (id (id x))))]]) (I (4padU x))
+
+
+let interchange+2 (x : *) (a : id (id (id (id x))) -> id (id (id (id x))))  (b : id (id (id (id x))) -> id (id (id (id x))))
+    = comp (4padU x) [[whiskering_interchange+ (3padU x) (2paddedU [[[id (id (id (id (id x))))]]] [[[a]]]) (2paddedU [[[b]]] [[[id (id (id (id (id x))))]]]) (I (3padU x))]] (I (4padU x))
+
+let interchange+3 (x : *) (a : id (id (id (id x))) -> id (id (id (id x))))  (b : id (id (id (id x))) -> id (id (id (id x))))
+    = comp (4padU x) [[comp (3padU x) [[[whiskering_interchange++ (2padU x) (1paddedU [[[[id (id (id (id (id x))))]]]] [[[[a]]]]) (1paddedU [[[[b]]]] [[[[id (id (id (id (id x))))]]]]) (I (2padU x))]]] (I (3padU x))]] (I (4padU x))
+
+coh interchange_inside+ (x(f(a(p(A(S)B)q)b)g)y(h(c(r(C(T)D)s)d)i)z) : comp (comp [[[[id A]]]] [[[[T]]]]) (comp [[[[S]]]] [[[[id D]]]]) -> comp [[[[S]]]] [[[[T]]]]
+
+let interchange+ (x : *) (a : id (id (id (id x))) -> id (id (id (id x))))  (b : id (id (id (id x))) -> id (id (id (id x))))
+ = comp
+ (interchange+1 a b)
+ (interchange+2 a b)
+ (interchange+3 a b)
+ (comp (4padU x) [[comp (3padU x) [[[comp (2padU x) [[[[interchange_inside+ b a]]]] (I (2padU x))]]] (I (3padU x))]] (I (4padU x)))
+
+coh tidyl+ (x) : comp (5padL (id (id (id (id x))))) (4paddedLto4paddedU (id (id (id (id x))))) -> 5padU x
+
+coh tidyr+ (x) : comp (4paddedUto4paddedR (id (id (id (id x))))) (I (op { 1 } (5padL (id (id (id (id x))))))) -> I (5padU x)
+
+let eh540 (x : *) (a : id (id (id (id x))) -> id (id (id (id x)))) (b : id (id (id (id x))) -> id (id (id (id x))))
+    	  : comp a b -> 5paddedU b a
+    	  = totalshape
+	  (6padL a) (op { 1 } (6padL b))
+	  (middlereplace+ x)
+	  (4paddedLto4paddedU_nat a)
+	  (4paddedUto4paddedR_nat b)
+	  (interchange+ a b)
+	  (tidyl+ x) (tidyr+ x)
diff --git a/examples/eckmann-hilton-versions/higher-eh/ehbasecases.catt b/examples/eckmann-hilton-versions/higher-eh/ehbasecases.catt
new file mode 100644
index 00000000..22069f46
--- /dev/null
+++ b/examples/eckmann-hilton-versions/higher-eh/ehbasecases.catt
@@ -0,0 +1,185 @@
+let padded1 (x : *) (p : x -> x) = p
+let bpadded1 (x : *) (y : *) (q : x -> y) = q
+
+coh pad1 (x) : id x -> padded1 (comp (id x) (id x))
+coh bpad1 (x(f)y) : f -> bpadded1 (comp f (id y))
+
+let padded2 (x : *) (p : comp (id x) (id x) -> comp (id x) (id x))
+    = comp (pad1 x) (padded1 [p]) (I (pad1 x))
+let bpadded2 (x : *) (y : *) (f : x -> y) (g : x -> y) (q : comp f (id y) -> comp g (id y))
+    = comp (bpad1 f) (bpadded1 [q]) (I (bpad1 g))
+
+coh pad2 (x) : id (id x) -> padded2 (comp [id (id x)] [id (id x)])
+coh bpad2 (x(f(a)g)y) : a -> bpadded2 (comp [a] [id (id y)])
+
+let padded3 (x : *) (p : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)])
+    = comp (pad2 x) (padded2 [p]) (I (pad2 x))
+let bpadded3 (x : *) (y : *) (f : x -> y) (g : x -> y) (a : f -> g) (b : f -> g) (q : comp [a] [id (id y)] -> comp [b] [id (id y)])
+    = comp (bpad2 a) (bpadded2 [q]) (I (bpad2 b))
+
+coh pad3 (x) : id (id (id x)) -> padded3 (comp [[id (id (id x))]] [[id (id (id x))]])
+coh bpad3 (x(f(a(X)b)g)y) : X -> bpadded3 (comp [[X]] [[id (id (id y))]])
+
+let padded4 (x : *) (p : comp [[id (id (id x))]] [[id  (id (id x))]] -> comp [[id (id (id x))]] [[id  (id (id x))]])
+    = comp (pad3 x) (padded3 [p]) (I (pad3 x))
+let bpadded4 (x : *) (y : *) (f : x -> y) (g : x -> y) (a : f -> g) (b : f -> g) (X : a -> b) (Y : a -> b) (q : comp [[X]] [[id (id (id y))]] -> comp [[Y]] [[id (id (id y))]])
+    = comp (bpad3 X) (bpadded3 [q]) (I (bpad3 Y))
+
+coh pad4 (x) : id (id (id (id x))) -> padded4 (comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+coh bpad4 (x(f(a(X(F)Y)b)g)y) : F -> bpadded4 (comp [[[F]]] [[[id (id (id (id y)))]]])
+
+let padded5 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+    = comp (pad4 x) (padded4 [p]) (I (pad4 x))
+let bpadded5 (x : *) (y : *) (f : x -> y) (g : x -> y) (a : f -> g) (b : f -> g) (X : a -> b) (Y : a -> b) (F : X -> Y) (G : X -> Y) (q : comp [[[F]]] [[[id (id (id (id y)))]]] -> comp [[[G]]] [[[id (id (id (id y)))]]])
+    = comp (bpad4 F) (bpadded4 [q]) (I (bpad4 G))
+
+coh pad5 (x) : id (id (id (id (id x)))) -> padded5 (comp [[[[id (id (id (id (id x))))]]]] [[[[id (id (id (id (id x))))]]]])
+coh bpad5 (x(f(a(X(F(A)G)Y)b)g)y) : A -> bpadded5 (comp [[[[A]]]] [[[[id (id (id (id (id y))))]]]])
+
+
+
+
+
+
+
+coh peel1 (x(f)y(g(a)h(b)i)z(j)w) : comp (comp f [a] j) (comp f [b] j) -> comp f [comp a b] j
+coh peel2 (x(f)y(g(a(X)b(Y)c)h)z(j)w) : comp (comp f [[X]] j) (comp f [[Y]] j) -> comp f [[comp X Y]] j
+coh peel3 (x(f)y(g(a(X(F)Y(G)Z)b)h)z(j)w) : comp (comp f [[[F]]] j) (comp f [[[G]]] j) -> comp f [[[comp F G]]] j
+
+let collapse3 (x : *) (p : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)]) (q : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)])
+    = peel1 (pad1 x) p q (I (pad1 x))
+
+coh interchange3 (x(f(a(X)b)g)y(h(c(Y)d)i)z) : comp (comp [[X]] [[id c]]) (comp [[id b]] [[Y]]) -> comp [[X]] [[Y]]
+
+let move_parallel3 (x : *) (a : id (id x) -> id (id x)) (b : id (id x) -> id (id x))
+    = comp (collapse3 (comp [[a]] [[id (id (id x))]]) (comp [[id (id (id x))]] [[b]])) (padded2 [[interchange3 a b]])
+
+
+coh interchange4 (x(f(a(X(F)Y)b)g)y(h(c(Z(G)W)d)i)z) : comp (comp [[[F]]] [[[id Z]]]) (comp [[[id Y]]] [[[G]]]) -> comp [[[F]]] [[[G]]]
+
+
+
+
+coh focus33tomiddle2 (x0(f1)x1(f2)x2(f3)x3(f4)x4(f5)x5(f6)x6) : comp (comp f1 f2 f3) (comp f4 f5 f6) -> comp f1 f2 (comp f3 f4) f5 f6
+
+coh 4unitor (x0(f1)x1(f2)x2(f3)x3(f4)x4) : comp f1 f2 (id x2) f3 f4 -> comp f1 (comp f2 f3) f4
+
+let collapse12 (x : *) (p : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)]) (q : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)])
+    : comp (padded1 [[p]]) (padded1 [[q]]) -> padded1 [[comp p q]]
+    = id (comp p q)
+
+let collapse21 (x : *) (p : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)]) (q : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)])
+    : comp (padded2 [p]) (padded2 [q]) -> padded2 [comp p q]
+    = comp (peel1 (pad1 x) (padded1 [[p]]) (padded1 [[q]]) (I (pad1 x))) (comp _ [[collapse12 p q]] _)
+
+let collapse30 (x : *) (p : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)]) (q : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)])
+    : comp (padded3 p) (padded3 q) -> padded3 (comp p q)
+    = comp
+    (focus33tomiddle2 (pad2 x) (padded2 [p]) (I (pad2 x)) (pad2 x) (padded2 [q]) (I (pad2 x)))
+    (comp _ _ [U (I (pad2 x))] _ _)
+    (4unitor (pad2 x) (padded2 [p]) (padded2 [q]) (I (pad2 x)))
+    (comp _ [collapse21 p q] _)
+
+let collapse13 (x : *) (p : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]]) (q : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]])
+    : comp (padded1 [[[p]]]) (padded1 [[[q]]]) -> padded1 [[[comp p q]]]
+    = id (comp p q)
+
+let collapse22 (x : *) (p : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]]) (q : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]])
+    : comp (padded2 [[p]]) (padded2 [[q]]) -> padded2 [[comp p q]]
+    = comp
+    (peel2 (pad1 x) (padded1 [[[p]]]) (padded1 [[[q]]]) (I (pad1 x))) (comp _ [[[collapse13 p q]]] _)
+
+let collapse31 (x : *) (p : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]]) (q : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]])
+    : comp (padded3 [p]) (padded3 [q]) -> padded3 [comp p q]
+    = comp (peel1 (pad2 x) (padded2 [[p]]) (padded2 [[q]]) (I (pad2 x))) (comp _ [[collapse22 p q]] _)
+
+let collapse40 (x : *) (p : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]]) (q : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]])
+    : comp (padded4 p) (padded4 q) -> padded4 (comp p q)
+    = comp
+    (focus33tomiddle2 (pad3 x) (padded3 [p]) (I (pad3 x)) (pad3 x) (padded3 [q]) (I (pad3 x)))
+    (comp _ _ [U (I (pad3 x))] _ _)
+    (4unitor (pad3 x) (padded3 [p]) (padded3 [q]) (I (pad3 x)))
+    (comp _ [collapse31 p q] _)
+
+let collapse14 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]]) (q : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+    : comp (padded1 [[[[p]]]]) (padded1 [[[[q]]]]) -> padded1 [[[[comp p q]]]]
+    = id (comp p q)
+
+let collapse23 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]]) (q : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+    : comp (padded2 [[[p]]]) (padded2 [[[q]]]) -> padded2 [[[comp p q]]]
+    = comp (peel3 (pad1 x) (padded1 [[[[p]]]]) (padded1 [[[[q]]]]) (I (pad1 x))) (comp _ [[[[collapse14 p q]]]] _)
+
+let collapse32 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]]) (q : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+    : comp (padded3 [[p]]) (padded3 [[q]]) -> padded3 [[comp p q]]
+    = comp (peel2 (pad2 x) (padded2 [[[p]]]) (padded2 [[[q]]]) (I (pad2 x))) (comp _ [[[collapse23 p q]]] _)
+
+let collapse41 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]]) (q : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+    : comp (padded4 [p]) (padded4 [q]) -> padded4 [comp p q]
+    = comp (peel1 (pad3 x) (padded3 [[p]]) (padded3 [[q]]) (I (pad3 x))) (comp _ [[collapse32 p q]] _)
+
+let collapse50 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]]) (q : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])
+    : comp (padded5 p) (padded5 q) -> padded5 (comp p q)
+    = comp
+    (focus33tomiddle2 (pad4 x) (padded4 [p]) (I (pad4 x)) (pad4 x) (padded4 [q]) (I (pad4 x)))
+    (comp _ _ [U (I (pad4 x))] _ _)
+    (4unitor (pad4 x) (padded4 [p]) (padded4 [q]) (I (pad4 x)))
+    (comp _ [collapse41 p q] _)
+
+coh interchange5 (x(f(a(X(F(A)G)Y)b)g)y(h(c(Z(H(B)K)W)d)i)z) : comp (comp [[[[A]]]] [[[[id H]]]]) (comp [[[[id G]]]] [[[[B]]]]) -> comp [[[[A]]]] [[[[B]]]]
+
+let hexcomp (x : *) (y- : *) (y+ : *) (y> : y- -> y+) (z- : *) (z+ : *) (z> : z- -> z+) (w : *) (f- : x -> y-) (f+ : x -> y+) (f> : comp f- y> -> f+) (g- : y- -> z-) (g+ : y+ -> z+) (g> : comp g- z> -> comp y> g+) (h- : z- -> w) (h+ : z+ -> w) (h> : h- -> comp z> h+)
+    = @comp _ [_] [f>] [_] [g>] _ [h>]
+
+let unbias1 (x : *) (p : x -> x) : bpadded1 p -> padded1 p
+    = id p
+coh factor1 (x) :  I (bpad1 (id x)) -> comp (unbias1 (comp (id x) (id x))) (I (pad1 x))
+coh unfactor1 (x) : comp (bpad1 (id x)) (unbias1 (comp (id x) (id x))) -> pad1 x
+
+let unbias2 (x : *) (p : comp (id x) (id x) -> comp (id x) (id x)) : bpadded2 p -> padded2 p
+    = hexcomp (unfactor1 x) (I (unbias1 [p])) (factor1 x)
+coh factor2 (x) : I (bpad2 (id (id x))) -> comp (unbias2 (comp [id (id x)] [id (id x)])) (I (pad2 x))
+coh unfactor2 (x) : comp (bpad2 (id (id x))) (unbias2 (comp [id (id x)] [id (id x)])) -> pad2 x
+
+let unbias3 (x : *) (p : comp [id (id x)] [id (id x)] -> comp [id (id x)] [id (id x)]) : bpadded3 p -> padded3 p
+    = hexcomp (unfactor2 x) (I (unbias2 [p])) (factor2 x)
+coh factor3 (x) : I (bpad3 (id (id (id x)))) -> comp (unbias3 (comp [[id (id (id x))]] [[id (id (id x))]])) (I (pad3 x))
+coh unfactor3 (x) : comp (bpad3 (id (id (id x)))) (unbias3 (comp [[id (id (id x))]] [[id (id (id x))]])) -> pad3 x
+
+let upad3 (x : *) (a : id (id x) -> id (id x))
+    = comp (bpad3 a) (unbias3 (comp [[a]] [[id (id (id x))]]))
+
+let eh320 (x : *) (a : id (id x) -> id (id x)) (b : id (id x) -> id (id x))
+    : comp a b -> padded3 (comp [[a]] [[b]])
+    = comp
+    (comp [upad3 a] [op { 1 } (upad3 b)])
+    (collapse30 (comp [[a]] [[id (id (id x))]]) (comp [[id (id (id x))]] [[b]]))
+    (padded3 [interchange3 a b])
+    
+let unbias4 (x : *) (p : comp [[id (id (id x))]] [[id (id (id x))]] -> comp [[id (id (id x))]] [[id (id (id x))]]) : bpadded4 p -> padded4 p
+    = hexcomp (unfactor3 x) (I (unbias3 [p])) (factor3 x)
+coh factor4 (x) : I (bpad4 (id (id (id (id x))))) -> comp (unbias4 (comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])) (I (pad4 x))
+coh unfactor4 (x) : comp (bpad4 (id (id (id (id x))))) (unbias4 (comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]])) -> pad4 x
+
+
+let upad4 (x : *) (a : id (id (id x)) -> id (id (id x)))
+    = comp (bpad4 a) (unbias4 (comp [[[a]]] [[[id (id (id (id x)))]]]))
+
+let eh430 (x : *) (a : id (id (id x)) -> id (id (id x))) (b : id (id (id x)) -> id (id (id x)))
+    : comp a b -> padded4 (comp [[[a]]] [[[b]]])
+    = comp
+    (comp [upad4 a] [op { 1 } (upad4 b)])
+    (collapse40 (comp [[[a]]] [[[id (id (id (id x)))]]]) (comp [[[id (id (id (id x)))]]] [[[b]]]))
+    (padded4 [interchange4 a b])
+
+let unbias5 (x : *) (p : comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]] -> comp [[[id (id (id (id x)))]]] [[[id (id (id (id x)))]]]) : bpadded5 p -> padded5 p
+    = hexcomp (unfactor4 x) (I (unbias4 [p])) (factor4 x)
+    
+let upad5 (x : *) (a : id (id (id (id x))) -> id (id (id (id x))))
+    = comp (bpad5 a) (unbias5 (comp [[[[a]]]] [[[[id (id (id (id (id x))))]]]]))
+
+let eh540 (x : *) (a : id (id (id (id x))) -> id (id (id (id x)))) (b : id (id (id (id x))) -> id (id (id (id x))))
+    : comp a b -> padded5 (comp [[[[a]]]] [[[[b]]]])
+    = comp
+    (comp [upad5 a] [op { 1 } (upad5 b)])
+    (collapse50 (comp [[[[a]]]] [[[[id (id (id (id (id x))))]]]]) (comp [[[[id (id (id (id (id x))))]]]] [[[[b]]]]))
+    (padded5 [interchange5 a b])
diff --git a/examples/horizontalinverses.catt b/examples/horizontalinverses.catt
new file mode 100644
index 00000000..47c43d86
--- /dev/null
+++ b/examples/horizontalinverses.catt
@@ -0,0 +1,15 @@
+coh unit_l (x(f)y) : f -> comp (id x) f
+
+coh unit_r (x(f)y) : f -> comp f (id y)
+
+coh h_unit_l (x(f(a)g)y) : a -> comp (unit_l f) (commp [id (id x)] [a]) (I(unit_l g))
+
+let v_inverse (x : *) (y : *) (f : x -> y) (g : x -> y) (if : y -> x) (ig : y -> x) (ef : id x -> comp f if) (ieig : comp ig g -> id y) (ia : if -> ig)
+=
+comp (unit_l g) (comp [ef] g) (comp f [ia] g) (comp f [ieig]) (I (unit_r f))
+
+let v_witness (x : *) (y : *) (f : x -> y) (g : x -> y) (if : y -> x) (ig : y -> x) (ef : id x -> comp f if) (ief : comp f if -> f) (eef : id (id x) -> comp ef ief) (ieg : comp g ig -> id x) (ieig : comp ig g -> id y) (a : f -> g) (ia : if -> ig) (ea: comp (ef) (comp [a] [ia]) (ieg) -> id (id x))
+: comp a (v_inverse ef ieig ia) a -> id f
+= comp
+(comp [h_unit_l a] (v_inverse ef ieig ia))
+

From e70f8123965ee63bd84e7d80c5ba8d3f3b53efef Mon Sep 17 00:00:00 2001
From: Wilf Offord <111688351+wilfofford@users.noreply.github.com>
Date: Mon, 8 Sep 2025 15:42:21 +0200
Subject: [PATCH 02/30] [eckmann-hilton] infrastructure for padding and
 repadding

---
 lib/padding.ml  | 521 ++++++++++++++++++++++++++++++++++++++++++++++++
 lib/padding.mli | 141 +++++++++++++
 2 files changed, 662 insertions(+)
 create mode 100644 lib/padding.ml
 create mode 100644 lib/padding.mli

diff --git a/lib/padding.ml b/lib/padding.ml
new file mode 100644
index 00000000..2e712f9d
--- /dev/null
+++ b/lib/padding.ml
@@ -0,0 +1,521 @@
+open Common
+open Kernel
+open Unchecked_types.Unchecked_types (Coh) (Tm)
+
+module type StringS = sig
+  val value : string
+end
+
+module Filtration = struct
+  (* Data defining a filtration *)
+  module type MakerS = sig
+    val min : int
+    val max : int
+    val ctx : int -> ctx
+    val v : int -> Var.t
+  end
+
+  (* Functions relative to a filtration *)
+  module type S = sig
+    include MakerS
+
+    val sub : int -> sub
+    val v_constr : int -> constr
+    val src_v : int -> constr
+    val tgt_v : int -> constr
+    val v_plus : int -> Var.t
+    val v_bridge : int -> Var.t
+    val in_plus : int -> sub
+    val in_minus : int -> sub
+  end
+
+  module Make (F : MakerS) : S = struct
+    include F
+
+    let v_constr i = (Var (F.v i), fst (List.assoc (F.v i) (F.ctx i)))
+    let src_v i = Construct.src 1 (v_constr i)
+    let tgt_v i = Construct.tgt 1 (v_constr i)
+
+    let to_db i =
+      let c = Functorialisation.ctx (F.ctx i) [ F.v i ] in
+      Unchecked.db_level_sub_inv c
+
+    let v_plus i = Display_maps.var_apply_sub (Var.Plus (F.v i)) (to_db i)
+    let v_bridge i = Display_maps.var_apply_sub (Var.Bridge (F.v i)) (to_db i)
+
+    let in_plus i =
+      let rec aux ctx =
+        match ctx with
+        | [] -> []
+        | (x, (_, _)) :: ctx when x == F.v i ->
+            (v i, (Var (v_plus i), false)) :: aux ctx
+        | (x, (_, b)) :: ctx ->
+            (x, (Unchecked.tm_apply_sub (Var x) (to_db i), b)) :: aux ctx
+      in
+      aux (F.ctx i)
+
+    let in_minus i =
+      let rec aux ctx =
+        match ctx with
+        | [] -> []
+        | (x, (_, _)) :: ctx when x == F.v i ->
+            (v i, (Var (v i), false)) :: aux ctx
+        | (x, (_, b)) :: ctx ->
+            (x, (Unchecked.tm_apply_sub (Var x) (to_db i), b)) :: aux ctx
+      in
+      aux (F.ctx i)
+
+    let sub i =
+      let w = v_constr (i + 1) in
+      let rec aux ctx =
+        match ctx with
+        | [] -> []
+        | (x, (_, _)) :: ctx when x = v i ->
+            (v_bridge i, (Construct.to_tm w, true))
+            :: (v_plus i, (Construct.(to_tm (tgt 1 w)), false))
+            :: (v i, (Construct.(to_tm (src 1 w)), false))
+            :: aux ctx
+        | (x, (_, b)) :: ctx -> (x, (Var x, b)) :: aux ctx
+      in
+      aux (ctx i)
+  end
+end
+
+module Padding = struct
+  let pad_one_step p q previous v sigma =
+    let prev =
+      Construct.tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sigma
+    in
+    Construct.comp3 (Tm.constr p) prev (Tm.constr q)
+
+  module type PaddingDataS = sig
+    val p : int -> Tm.t
+    val q : int -> Tm.t
+  end
+
+  module type PaddedS = sig
+    val padded : int -> Tm.t
+  end
+
+  module Padded (F : Filtration.S) (D : PaddingDataS) (Name : StringS) :
+    PaddedS = struct
+    let memo_padded : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+
+    let rec padded i =
+      let compute_padded i =
+        let name = (Printf.sprintf "%s.Padding(%d)" Name.value i, 0, []) in
+        let padded_constr =
+          if i = F.min then F.v_constr i
+          else
+            pad_one_step
+              (D.p (i - 1))
+              (D.q (i - 1))
+              (padded (i - 1))
+              (F.v (i - 1))
+              (F.sub (i - 1))
+        in
+        check_constr (F.ctx i) ~name padded_constr
+      in
+      match Hashtbl.find_opt memo_padded i with
+      | Some padded -> padded
+      | None ->
+          let padded = compute_padded i in
+          Hashtbl.add memo_padded i padded;
+          padded
+  end
+
+  (* Several padding data we consider are canonical -- they are given by a single
+     coherence in a well-chosen pasting scheme. The following aims at streamlining
+     the construction of such padding data *)
+  module type CanonicalPaddingDataArgsS = sig
+    val ps : int -> ps
+    val p_src : int -> constr
+    val q_tgt : int -> constr
+    val p_inc : int -> constr list
+    val q_inc : int -> constr list
+    val pad_in_ps : int -> sub
+  end
+
+  module CanonicalPaddingData
+      (F : Filtration.S)
+      (Args : CanonicalPaddingDataArgsS)
+      (P : PaddedS)
+      (Name : StringS) =
+  struct
+    let p i =
+      let padded_subbed =
+        Construct.tm_app_sub (P.padded i) (Args.pad_in_ps i)
+      in
+      let ty = Construct.arr (Args.p_src i) padded_subbed in
+      let name = (Printf.sprintf "%s.p(%d)" Name.value i, 0, []) in
+      let coh = check_coh (Args.ps i) ty name in
+      check_constr (F.ctx (i + 1)) (Construct.coh_app coh (Args.p_inc i))
+
+    let q i =
+      let padded_subbed =
+        Construct.tm_app_sub (P.padded i) (Args.pad_in_ps i)
+      in
+      let ty = Construct.arr padded_subbed (Args.q_tgt i) in
+      let name = (Printf.sprintf "%s.p(%d)" Name.value i, 0, []) in
+      let coh = check_coh (Args.ps i) ty name in
+      check_constr (F.ctx (i + 1)) (Construct.coh_app coh (Args.q_inc i))
+  end
+
+  module type MakerS = sig
+    module F : Filtration.S
+    module D : PaddingDataS
+    module P : PaddedS
+
+    val name : string
+  end
+
+  module type S = sig
+    include MakerS
+
+    val ctx : ctx
+    val v : Var.t
+    val v_constr : constr
+    val v_plus : Var.t
+    val v_bridge : Var.t
+    val p : Tm.t
+    val q : Tm.t
+    val padded : Tm.t
+    val padded_func : int -> int -> Tm.t
+  end
+
+  module Make (A : MakerS) : S = struct
+    module F = A.F
+
+    module D = struct
+      include A.D
+
+      let memo_p : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+      let memo_q : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+
+      let p i =
+        match Hashtbl.find_opt memo_p i with
+        | Some padded -> padded
+        | None ->
+            let padded = p i in
+            Hashtbl.add memo_p i padded;
+            padded
+
+      let q i =
+        match Hashtbl.find_opt memo_q i with
+        | Some padded -> padded
+        | None ->
+            let padded = q i in
+            Hashtbl.add memo_q i padded;
+            padded
+    end
+
+    module P = A.P
+
+    let name = A.name
+    let ctx = F.ctx F.max
+    let v = F.v F.max
+    let v_constr = F.v_constr F.max
+    let v_plus = F.v_plus F.max
+    let v_bridge = F.v_bridge F.max
+    let p = D.p F.max
+    let q = D.q F.max
+    let padded = P.padded F.max
+
+    (* Assumption: t is in the i-th context of the filtration *)
+    let rec iterated_func t i r =
+      match r with
+      | 0 -> t
+      | r ->
+          check_constr
+            (F.ctx (i + r))
+            (Construct.tm_app_sub
+               (Functorialisation.tm
+                  (iterated_func t i (r - 1))
+                  [ (F.v (i + r), 1) ])
+               (F.sub (i + r - 1)))
+
+    let padded_func i r = iterated_func (P.padded i) i r
+  end
+
+  module type MakerCanonicalS = sig
+    module F : Filtration.S
+    module D : CanonicalPaddingDataArgsS
+
+    val name : string
+  end
+
+  module MakeCanonical (A : MakerCanonicalS) = Make (struct
+    module F = A.F
+
+    let name = A.name
+
+    module Name : StringS = struct
+      let value = A.name
+    end
+
+    module rec D : PaddingDataS = CanonicalPaddingData (F) (A.D) (P) (Name)
+    and P : PaddedS = Padded (F) (D) (Name)
+  end)
+end
+
+module type FiltrationMorphismS = sig
+  val sub : int -> sub
+  val name : string
+end
+
+module PaddingApp
+    (Tgt : Filtration.S)
+    (M : FiltrationMorphismS)
+    (P : Padding.S) : Padding.S = Padding.Make (struct
+  module F = Tgt
+
+  module D = struct
+    let p i =
+      check_constr
+        (Tgt.ctx (i + 1))
+        (Construct.tm_app_sub (P.D.p i) (M.sub (i + 1)))
+
+    let q i =
+      check_constr
+        (Tgt.ctx (i + 1))
+        (Construct.tm_app_sub (P.D.q i) (M.sub (i + 1)))
+  end
+
+  let name = Printf.sprintf "%s[%s]" P.name M.name
+
+  module P = struct
+    let padded i =
+      check_constr (Tgt.ctx i) (Construct.tm_app_sub (P.P.padded i) (M.sub i))
+  end
+end)
+
+module Suspend (P : Padding.S) : Padding.S = Padding.Make (struct
+  module F = Filtration.Make (struct
+    let min = P.F.min + 1
+    let max = P.F.max + 1
+    let ctx i = Suspension.ctx (Some 1) (P.F.ctx (i - 1))
+    let v i = P.F.v i
+  end)
+
+  module D = struct
+    let p i = Suspension.checked_tm (Some 1) (P.D.p (i - 1))
+    let q i = Suspension.checked_tm (Some 1) (P.D.q (i - 1))
+  end
+
+  let name = Printf.sprintf "Σ%s" P.name
+
+  module P = struct
+    let padded i = Suspension.checked_tm (Some 1) (P.P.padded (i - 1))
+  end
+end)
+
+module Repadding = struct
+  let hexcomp fminus fplus ybridge fbridge gminus gplus gbridge zbridge hminus
+      hplus hbridge =
+    let d = Construct.dim fminus - 1 in
+    let db n = Var.Db n in
+    let hex =
+      Functorialisation.coh (Builtin.comp_n 3) [ db 6; db 4; db 3; db 2; db 1 ]
+    in
+    let hex = Suspension.checked_tm (Some d) hex in
+    let x = Construct.src 1 fminus in
+    let yminus = Construct.tgt 1 fminus in
+    let yplus = Construct.tgt 1 fplus in
+    let zminus = Construct.src 1 hminus in
+    let zplus = Construct.src 1 hplus in
+    let w = Construct.tgt 1 hminus in
+    let rec list_tgt_src ty =
+      match ty with
+      | Obj -> []
+      | Arr (a, u, v) -> (v, a) :: (u, a) :: list_tgt_src a
+      | _ -> assert false
+    in
+    let sub =
+      hbridge :: hplus :: hminus :: w :: gbridge :: gplus :: gminus :: zbridge
+      :: zplus :: zminus :: fbridge :: fplus :: fminus :: ybridge :: yplus
+      :: yminus :: x
+      :: list_tgt_src (snd w)
+    in
+    (* The call to sub_ps_to_sub is a bit of a hack, relying on the fact that all
+       checked terms use deBruijn. Further refactoring to be done in the kernel to
+       enforce this more statically *)
+    Construct.tm_app hex sub
+
+  let repad_one_step p_0 p_1 f q_0 q_1 g previous iota_minus iota_plus v sub =
+    let padding_0, padding_1 = Tm.bdry previous in
+    hexcomp (Tm.constr p_0) (Tm.constr p_1)
+      Construct.(apply_sub (tm_app_sub previous iota_minus) sub)
+      (Tm.constr f)
+      Construct.(tm_app_sub (Functorialisation.tm padding_0 [ (v, 1) ]) sub)
+      Construct.(tm_app_sub (Functorialisation.tm padding_1 [ (v, 1) ]) sub)
+      Construct.(
+        inverse (tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sub))
+      Construct.(apply_sub (tm_app_sub previous iota_plus) sub)
+      (Tm.constr q_0) (Tm.constr q_1) (Tm.constr g)
+
+  module type RepaddingDataS = sig
+    val f : int -> Tm.t
+    val g : int -> Tm.t
+  end
+
+  module type RepaddedS = sig
+    val repad : int -> Tm.t
+  end
+
+  module Repadded
+      (P1 : Padding.S)
+      (P2 : Padding.S)
+      (D : RepaddingDataS)
+      (Name : StringS) =
+  struct
+    let memo_repadded = Hashtbl.create 77
+
+    let rec repad i =
+      let compute_repadding i =
+        let repadding_constr =
+          if i = P1.F.min then Construct.id_n 1 (P1.F.v_constr i)
+          else
+            let previous = repad (i - 1) in
+            let sigma = P1.F.sub (i - 1) in
+            let f, g = (D.f (i - 1), D.g (i - 1)) in
+            repad_one_step
+              (P1.D.p (i - 1))
+              (P2.D.p (i - 1))
+              f
+              (P1.D.q (i - 1))
+              (P2.D.q (i - 1))
+              g previous
+              (P1.F.in_minus (i - 1))
+              (P1.F.in_plus (i - 1))
+              (P1.F.v (i - 1))
+              sigma
+        in
+        let name = (Printf.sprintf "%s.Repadding(%d)" Name.value i, 0, []) in
+        check_constr (P1.F.ctx i) ~name repadding_constr
+      in
+      match Hashtbl.find_opt memo_repadded i with
+      | Some t -> t
+      | None ->
+          let repadded = compute_repadding i in
+          Hashtbl.add memo_repadded i repadded;
+          repadded
+  end
+
+  module type CanonicalRepaddingDataArgsS = sig
+    val ps : int -> ps
+    val incl : int -> constr list
+  end
+
+  module CanonicalRepaddingData
+      (Args : CanonicalRepaddingDataArgsS)
+      (P1 : Padding.S)
+      (P2 : Padding.S)
+      (R : RepaddedS)
+      (Name : StringS) : RepaddingDataS = struct
+    let f i =
+      let ty =
+        Construct.(
+          arr
+            (wcomp
+               (Construct.develop (Tm.constr (P1.D.p i)))
+               i
+               (tm_app_sub (R.repad i)
+                  (Unchecked.sub_apply_sub (P1.F.in_minus i) (P1.F.sub i))))
+            (Construct.develop (Tm.constr (P2.D.p i))))
+      in
+      let name = (Printf.sprintf "%s.f(%d)" Name.value i, 0, []) in
+      let coh = check_coh (Args.ps i) ty name in
+      check_constr (P1.F.ctx i) (Construct.coh_app coh (Args.incl i))
+
+    let g i =
+      let ty =
+        Construct.(
+          arr
+            (Construct.develop (Tm.constr (P1.D.q i)))
+            (wcomp
+               (tm_app_sub (R.repad i)
+                  (Unchecked.sub_apply_sub (P1.F.in_plus i) (P1.F.sub i)))
+               i
+               (Construct.develop (Tm.constr (P2.D.q i)))))
+      in
+      let name = (Printf.sprintf "%s.g(%d)" Name.value i, 0, []) in
+      let coh = check_coh (Args.ps i) ty name in
+      check_constr (P1.F.ctx i) (Construct.coh_app coh (Args.incl i))
+  end
+
+  module type MakerS = sig
+    module P1 : Padding.S
+    module P2 : Padding.S
+    module D : RepaddingDataS
+    module R : RepaddedS
+
+    val name : string
+  end
+
+  module type S = sig
+    include MakerS
+
+    val repadded : Tm.t
+    val f : Tm.t
+    val g : Tm.t
+  end
+
+  module Make (A : MakerS) : S = struct
+    module P1 = A.P1
+    module P2 = A.P2
+
+    module D = struct
+      include A.D
+
+      let memo_f : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+      let memo_g : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+
+      let f i =
+        match Hashtbl.find_opt memo_f i with
+        | Some padded -> padded
+        | None ->
+            let padded = f i in
+            Hashtbl.add memo_f i padded;
+            padded
+
+      let g i =
+        match Hashtbl.find_opt memo_g i with
+        | Some padded -> padded
+        | None ->
+            let padded = g i in
+            Hashtbl.add memo_g i padded;
+            padded
+    end
+
+    module R = A.R
+
+    let name = A.name
+    let repadded = R.repad P1.F.max
+    let f = D.f (P1.F.max - 1)
+    let g = D.g (P1.F.max - 1)
+  end
+
+  module type MakerCanonicalS = sig
+    module P1 : Padding.S
+    module P2 : Padding.S
+    module D : CanonicalRepaddingDataArgsS
+
+    val name : string
+  end
+
+  module MakeCanonical (A : MakerCanonicalS) : S = Make (struct
+    module P1 = A.P1
+    module P2 = A.P2
+
+    module Name = struct
+      let value = A.name
+    end
+
+    let name = A.name
+
+    module rec D : RepaddingDataS =
+      CanonicalRepaddingData (A.D) (P1) (P2) (R) (Name)
+
+    and R : RepaddedS = Repadded (P1) (P2) (D) (Name)
+  end)
+end
diff --git a/lib/padding.mli b/lib/padding.mli
new file mode 100644
index 00000000..b0ec31e2
--- /dev/null
+++ b/lib/padding.mli
@@ -0,0 +1,141 @@
+open Common
+open Kernel
+open Unchecked_types.Unchecked_types(Coh)(Tm)
+
+module type StringS = sig
+  val value : string
+end
+
+module Filtration : sig
+  (* Data needed to define a filtration *)
+  module type MakerS = sig
+    val min : int
+    val max : int
+    val ctx : int -> ctx
+    val v : int -> Var.t
+  end
+
+  (* Data of the filtration *)
+  module type S = sig
+    include MakerS
+
+    val sub : int -> sub
+    val v_constr : int -> constr
+    val src_v : int -> constr
+    val tgt_v : int -> constr
+    val v_plus : int -> Var.t
+    val v_bridge : int -> Var.t
+    val in_plus : int -> sub
+    val in_minus : int -> sub
+  end
+
+  module Make (_ : MakerS) : S
+end
+
+module Padding : sig
+  module type PaddingDataS = sig
+    val p : int -> Tm.t
+    val q : int -> Tm.t
+  end
+
+  module type PaddedS = sig
+    val padded : int -> Tm.t
+  end
+
+  module type CanonicalPaddingDataArgsS = sig
+    val ps : int -> ps
+    val p_src : int -> constr
+    val q_tgt : int -> constr
+    val p_inc : int -> constr list
+    val q_inc : int -> constr list
+    val pad_in_ps : int -> sub
+  end
+
+  module type MakerS = sig
+    module F : Filtration.S
+    module D : PaddingDataS
+    module P : PaddedS
+
+    val name : string
+  end
+
+  module type S = sig
+    include MakerS
+
+    val ctx : ctx
+    val v : Var.t
+    val v_constr : constr
+    val v_plus : Var.t
+    val v_bridge : Var.t
+    val p : Tm.t
+    val q : Tm.t
+    val padded : Tm.t
+    val padded_func : int -> int -> Tm.t
+  end
+
+  module Make (_ : MakerS) : S
+
+  module type MakerCanonicalS = sig
+    module F : Filtration.S
+    module D : CanonicalPaddingDataArgsS
+
+    val name : string
+  end
+
+  module MakeCanonical (_ : MakerCanonicalS) : S
+end
+
+module type FiltrationMorphismS = sig
+  val sub : int -> sub
+  val name : string
+end
+
+module PaddingApp (_ : Filtration.S) (_ : FiltrationMorphismS) (_ : Padding.S) :
+  Padding.S
+
+module Suspend (_ : Padding.S) : Padding.S
+
+module Repadding : sig
+  module type RepaddingDataS = sig
+    val f : int -> Tm.t
+    val g : int -> Tm.t
+  end
+
+  module type RepaddedS = sig
+    val repad : int -> Tm.t
+  end
+
+  module type CanonicalRepaddingDataArgsS = sig
+    val ps : int -> ps
+    val incl : int -> constr list
+  end
+
+  module type MakerS = sig
+    module P1 : Padding.S
+    module P2 : Padding.S
+    module D : RepaddingDataS
+    module R : RepaddedS
+
+    val name : string
+  end
+
+  module type S = sig
+    include MakerS
+
+    val repadded : Tm.t
+    val f : Tm.t
+    val g : Tm.t
+  end
+
+  module Make (_ : MakerS) : S
+
+  module type MakerCanonicalS = sig
+    module P1 : Padding.S
+    module P2 : Padding.S
+    module D : CanonicalRepaddingDataArgsS
+
+    val name : string
+  end
+
+  module MakeCanonical (_ : MakerCanonicalS) : S
+end

From b5fbd09b4f1d3476f8589b3bd4c1189f3e82ec28 Mon Sep 17 00:00:00 2001
From: Wilf Offord <111688351+wilfofford@users.noreply.github.com>
Date: Mon, 18 Aug 2025 11:36:17 +0100
Subject: [PATCH 03/30] [eckmann-hilton] definition and parsing of eh cells

---
 examples/eh-builtin.catt |  16 +
 lib/eh.ml                | 610 +++++++++++++++++++++++++++++++++++++++
 lib/eh.mli               |   4 +
 lib/environment.ml       |   2 +
 lib/lexer.mll            |  10 +
 lib/parser.mly           |   4 +
 lib/raw.ml               |   6 +-
 lib/raw_types.mli        |   2 +
 lib/translate_raw.ml     |   6 +
 9 files changed, 659 insertions(+), 1 deletion(-)
 create mode 100644 examples/eh-builtin.catt
 create mode 100644 lib/eh.ml
 create mode 100644 lib/eh.mli

diff --git a/examples/eh-builtin.catt b/examples/eh-builtin.catt
new file mode 100644
index 00000000..1f4c8d01
--- /dev/null
+++ b/examples/eh-builtin.catt
@@ -0,0 +1,16 @@
+check eh(2,0,1)
+check eh(3,0,1)
+check eh(4,2,1)
+check eh(3,1,2)
+check eh(4,3,2)
+check eh(3,1,2)
+check eh(4,2,3)
+check eh(3,0,2)
+check eh(2,1,0)
+check eh(9,8,7)
+check eh(3,2,0)
+check EH(2,0,1)
+check EH(3,0,1)
+check EH(3,1,2)
+check EH(3,1,2)
+check EH(3,2,0)
diff --git a/lib/eh.ml b/lib/eh.ml
new file mode 100644
index 00000000..1ed77466
--- /dev/null
+++ b/lib/eh.ml
@@ -0,0 +1,610 @@
+open Common
+open Kernel
+open Unchecked_types.Unchecked_types (Coh) (Tm)
+
+module type EHArgsS = sig
+  val n : int
+  val k : int
+  val l : int
+end
+
+module type BiasedPaddingArgsS = sig
+  val n : int
+end
+
+let memo_args = Hashtbl.create 97
+let memo_args_biased = Hashtbl.create 97
+
+let args n k l =
+  match Hashtbl.find_opt memo_args (n, k, l) with
+  | Some m -> m
+  | None ->
+      let res =
+        (module struct
+          let n = n
+          let k = k
+          let l = l
+        end : EHArgsS)
+      in
+      Hashtbl.add memo_args (n, k, l) res;
+      res
+
+let args_biased n =
+  match Hashtbl.find_opt memo_args_biased n with
+  | Some m -> m
+  | None ->
+      let res =
+        (module struct
+          let n = n
+        end : BiasedPaddingArgsS)
+      in
+      Hashtbl.add memo_args_biased n res;
+      res
+
+module UnbiasedPadding (Args : EHArgsS) = Padding.Padding.MakeCanonical (struct
+  let name = "UBPad"
+  let x = Var.Db 0
+  let x_constr = (Var x, Obj)
+
+  let id2 i j =
+    let id = Construct.id_n i (Var x, Obj) in
+    if j < i then Construct.wcomp id j id else id
+
+  let id_l_id i = id2 i Args.l
+
+  module F = Padding.Filtration.Make (struct
+    let min = Int.min Args.k Args.l + 1
+    let max = Args.n
+    let v _ = Var.Db 1
+    let ty i = Construct.arr (id_l_id i) (id_l_id i)
+    let ctx i = [ (v i, (ty (i - 1), true)); (x, (Obj, false)) ]
+  end)
+
+  module D = struct
+    let ps _ = Unchecked.disc 0
+    let p_src i = id2 i Args.k
+    let q_tgt i = id2 i Args.k
+    let p_inc _ = [ x_constr ]
+    let q_inc _ = [ x_constr ]
+
+    let pad_in_ps i =
+      [ (F.v i, (Construct.to_tm (id_l_id i), true)); (x, (Var x, false)) ]
+  end
+end)
+
+(* Find a good place for these *)
+let d_src i = (Var (Var.Db (2 * i)), Unchecked.disc_type i)
+let d_tgt i = (Var (Var.Db ((2 * i) + 1)), Unchecked.disc_type i)
+
+let t_comp_id d t =
+  if d = 0 then t else Construct.(wcomp t 0 (id_n d (d_tgt 0)))
+
+module ForwardBiasedPadding (Args : BiasedPaddingArgsS) =
+Padding.Padding.MakeCanonical (struct
+  let name = "FPad"
+
+  module F = Padding.Filtration.Make (struct
+    let min = 1
+    let max = Args.n
+    let ctx i = Unchecked.ps_to_ctx (Unchecked.disc i)
+    let v i = Var.Db (2 * i)
+  end)
+
+  module D = struct
+    let ps i = Unchecked.disc i
+    let p_src i = t_comp_id i (F.src_v (i + 1))
+    let q_tgt i = p_src i
+    let p_inc i = [ (Var (Var.Db (2 * i)), Unchecked.disc_type i) ]
+    let q_inc i = [ (Var (Var.Db ((2 * i) + 1)), Unchecked.disc_type i) ]
+    let pad_in_ps i = Unchecked.(identity (ps_to_ctx (ps i)))
+  end
+end)
+
+module BackwardBiasedPadding (Args : BiasedPaddingArgsS) =
+Padding.Padding.MakeCanonical (struct
+  let name = "BPad"
+
+  module F = Padding.Filtration.Make (struct
+    let min = 1
+    let max = Args.n
+    let ty_v i = Construct.arr (t_comp_id i (d_src i)) (t_comp_id i (d_tgt i))
+    let v i = Var.Db (2 * i)
+    let ctx i = (v i, (ty_v (i - 1), true)) :: Unchecked.sphere (i - 1)
+  end)
+
+  module D = struct
+    let ps i = Unchecked.disc i
+    let p_src i = d_src i
+    let q_tgt i = d_src i
+    let p_inc i = [ d_src i ]
+    let q_inc i = [ d_tgt i ]
+
+    let pad_in_ps i =
+      (F.v i, (Construct.to_tm (F.src_v (i + 1)), true))
+      :: Unchecked.(identity (sphere (i - 1)))
+  end
+end)
+
+module ForwardToUnbiasedRepadding (Args : BiasedPaddingArgsS) =
+Padding.Repadding.MakeCanonical (struct
+  let name = "FToURepad"
+
+  module EHArgs = (val args Args.n 0 (Args.n - 1) : EHArgsS)
+  module P2 = UnbiasedPadding (EHArgs)
+  module FP = ForwardBiasedPadding (Args)
+
+  module M : Padding.FiltrationMorphismS = struct
+    let name = "id"
+
+    let sub i =
+      Unchecked.sub_ps_to_sub
+        (Construct.characteristic_sub_ps (P2.F.v_constr i))
+  end
+
+  module P1 = Padding.PaddingApp (P2.F) (M) (FP)
+
+  module D = struct
+    let ps _ = Br []
+    let incl _ = [ (Var (Var.Db 0), Obj) ]
+  end
+end)
+
+module BackwardToUnbiasedRepadding (Args : BiasedPaddingArgsS) =
+Padding.Repadding.MakeCanonical (struct
+  let name = "BToURepad"
+
+  module EHArgs = (val args Args.n (Args.n - 1) 0)
+  module P2 = UnbiasedPadding (EHArgs)
+  module BP = BackwardBiasedPadding (Args)
+
+  module M : Padding.FiltrationMorphismS = struct
+    let name = "id"
+
+    let sub i =
+      let id_pt i = Construct.(to_tm (id_n i (Var (Var.Db 0), Obj))) in
+      let rec sphere_to_point i =
+        match i with
+        | -1 -> []
+        | i ->
+            (Var.Db ((2 * i) + 1), (id_pt i, false))
+            :: (Var.Db (2 * i), (id_pt i, false))
+            :: sphere_to_point (i - 1)
+      in
+      (BP.F.v i, (Var (P2.F.v i), true)) :: sphere_to_point (i - 1)
+  end
+
+  module P1 = Padding.PaddingApp (P2.F) (M) (BP)
+
+  module D = struct
+    let ps _ = Br []
+    let incl _ = [ (Var (Var.Db 0), Obj) ]
+  end
+end)
+
+module SuspUnbiasedToUnbiasedRepadding (Args : EHArgsS) =
+Padding.Repadding.MakeCanonical (struct
+  let name = "ΣUToURepad"
+
+  module PrevArgs = (val args (Args.n - 1) (Args.k - 1) (Args.l - 1))
+
+  let x = Var.Db 0
+  let x_constr = (Var x, Obj)
+
+  module P2 = UnbiasedPadding (Args)
+  module PrevA = UnbiasedPadding (PrevArgs)
+  module Prev = Padding.Suspend (UnbiasedPadding (PrevArgs))
+
+  module M : Padding.FiltrationMorphismS = struct
+    let name = "Susp"
+
+    let sub _ =
+      let list = [ P2.v_constr; Construct.id x_constr; x_constr; x_constr ] in
+      Construct.make_sub Prev.ctx list
+  end
+
+  module P1 = Padding.PaddingApp (P2.F) (M) (Prev)
+
+  module D = struct
+    let ps _ = Br []
+    let incl _ = [ x_constr ]
+  end
+end)
+
+module PseudoFunctorialityUnbiasedPadding (Args : EHArgsS) = struct
+  module UP = UnbiasedPadding (Args)
+
+  let x = Var.Db 0
+  let w = Var.Db 2
+  let ty = snd UP.v_constr
+  let ctx = (w, (ty, true)) :: UP.ctx
+  let w_constr = (Var w, ty)
+  let x_constr = (Var x, Obj)
+  let v_constr = UP.v_constr
+
+  let assoc n =
+    let tree = Builtin.Comp.tree 6 in
+    let f i = Builtin.Comp.f i in
+    let ty =
+      Construct.(
+        arr
+          (wcomp (comp3 (f 1) (f 2) (f 3)) 0 (comp3 (f 4) (f 5) (f 6)))
+          (comp3 (f 1) (comp3 (f 2) (wcomp (f 3) 0 (f 4)) (f 5)) (f 6)))
+    in
+    Suspension.coh (Some n) (check_coh tree ty ("_builtin_assoc", 0, []))
+
+  let unitor n =
+    let tree = Builtin.Comp.tree 2 in
+    let f i = Builtin.Comp.f i in
+    let x i = Builtin.Comp.x i in
+    let ty =
+      Construct.(arr (comp3 (f 1) (id_n 1 (x 1)) (f 2)) (wcomp (f 1) 0 (f 2)))
+    in
+    Suspension.coh (Some n) (check_coh tree ty ("_builtin_unitor", 0, []))
+
+  let intch n i =
+    assert (n >= 2);
+    let ps =
+      Br [ Br []; Suspension.ps (Some (n - 2)) (Br [ Br []; Br [] ]); Br [] ]
+    in
+    let tdb i = Var (Var.Db i) in
+    let d_L = (tdb 2, Arr (Obj, tdb 0, tdb 1)) in
+    let d_R = (tdb ((2 * n) + 6), Arr (Obj, tdb 3, tdb ((2 * n) + 5))) in
+    let d_max i =
+      let rec ty k =
+        if k = 1 then Arr (Obj, tdb 1, tdb 3)
+        else Arr (ty (k - 1), tdb (2 * k), tdb ((2 * k) + 1))
+      in
+      let d i =
+        let lvl = if i = 0 then 2 * n else (2 * n) + (2 * i) - 1 in
+        (tdb lvl, ty (n - 1))
+      in
+      (tdb ((2 * n) + (2 * i)), Construct.arr (d (i - 1)) (d i))
+    in
+    let ty =
+      Construct.(
+        arr
+          (comp
+             (wcomp_n 0 [ d_L; d_max 1; d_R ])
+             (wcomp_n 0 [ d_L; d_max 2; d_R ]))
+          (wcomp_n 0 [ d_L; comp_n [ d_max 1; d_max 2 ]; d_R ]))
+    in
+    Suspension.coh (Some i)
+      (check_coh ps ty ("_builtin_intch_chi" ^ string_of_int n, 0, []))
+
+  let rec psfpad_aux i =
+    let m = UP.F.min in
+    let n = UP.F.max in
+    let v_c = v_constr in
+    let w_c = w_constr in
+    let w_sub = [ w_constr; x_constr ] in
+    let witness_constr =
+      match i with
+      | i when i = m -> Construct.id_n 1 (Construct.wcomp v_c (n - 1) w_c)
+      | i when m < i -> (
+          let p, q = (UP.D.p (i - 1), UP.D.q (i - 1)) in
+          let p, q = (Tm.constr p, Tm.constr q) in
+          let t = UP.padded_func (i - 1) (n - i + 1) in
+          let tv = Tm.constr t in
+          let tw = Construct.tm_app t w_sub in
+          match i with
+          | i when i < n ->
+              let intch =
+                Construct.coh_app (intch (n - i + 1) (i - 1)) [ p; tv; tw; q ]
+              in
+              Construct.wcomp intch n
+                (Construct.wcomp_n (i - 1)
+                   [ p; Tm.constr (psfpad_aux (i - 1)); q ])
+          | i when i = n ->
+              let assoc =
+                Construct.coh_app (assoc (n - 1)) [ p; tv; q; p; tw; q ]
+              in
+              let w = Construct.witness q in
+              let unitor = Construct.coh_app (unitor (n - 1)) [ tv; tw ] in
+              Construct.comp_n
+                [
+                  assoc;
+                  Construct.wcomp_n (n - 1)
+                    [ p; Construct.wcomp_n (n - 1) [ tv; w; tw ]; q ];
+                  Construct.wcomp_n (n - 1) [ p; unitor; q ];
+                  Construct.wcomp_n (n - 1)
+                    [ p; Tm.constr (psfpad_aux (n - 1)); q ];
+                ]
+          | _ ->
+              Error.fatal
+                "[EH] Wrong arguments in pseudofunctoriality of padding")
+      | _ ->
+          Error.fatal "[EH] Wrong arguments in pseudofunctoriality of padding"
+    in
+    check_constr ctx witness_constr
+
+  let psfpad = psfpad_aux Args.n
+end
+
+module EHCtx (EHArgs : EHArgsS) = struct
+  let x = Var.Db 0
+  let a = Var.Db 1
+  let b = Var.Db 2
+  let id = Construct.id_n (EHArgs.n - 1) (Var x, Obj)
+  let ty = Construct.arr id id
+  let ctx = [ (b, (ty, true)); (a, (ty, true)); (x, (Obj, false)) ]
+  let x_constr = (Var x, Obj)
+  let a_constr = (Var a, ty)
+  let b_constr = (Var b, ty)
+
+  let a_comp_id =
+    if EHArgs.l = EHArgs.n - 1 then a_constr
+    else Construct.wcomp a_constr EHArgs.l (Construct.id_n 1 id)
+
+  let id_comp_b =
+    if EHArgs.l = EHArgs.n - 1 then b_constr
+    else Construct.wcomp (Construct.id_n 1 id) EHArgs.l b_constr
+
+  module UP = UnbiasedPadding (EHArgs)
+
+  let a_comp_id_sub = [ a_comp_id; x_constr ]
+  let id_comp_b_sub = [ id_comp_b; x_constr ]
+end
+
+module BaseCases (EHArgs : EHArgsS) = struct
+  let intch n =
+    let ps = Br [ Unchecked.disc (n - 1); Unchecked.disc (n - 1) ] in
+    let rec disc_type_r = function
+      | 0 -> Obj
+      | 1 -> Arr (Obj, Var (Var.Db 1), Var (Var.Db ((2 * n) + 1)))
+      | k ->
+          Arr
+            ( disc_type_r (k - 1),
+              Var (Var.Db ((2 * n) + (2 * k) - 2)),
+              Var (Var.Db ((2 * n) + (2 * k) - 1)) )
+    in
+    let d_l = (Var (Var.Db (2 * n)), Unchecked.disc_type n) in
+    let d_r = (Var (Var.Db (4 * n)), disc_type_r n) in
+    let ty =
+      Construct.arr
+        (Construct.wcomp
+           (Construct.wcomp d_l 0 (Construct.id_n 1 (Construct.src 1 d_r)))
+           (n - 1)
+           (Construct.wcomp (Construct.id_n 1 (Construct.tgt 1 d_l)) 0 d_r))
+        (Construct.wcomp d_l 0 d_r)
+    in
+    let name = (Printf.sprintf "intch(%d,%d)" n 0, 0, []) in
+    check_coh ps ty name
+
+  module GT (Args : BiasedPaddingArgsS) = struct
+    module BP = BackwardBiasedPadding (Args)
+    module BToU = BackwardToUnbiasedRepadding (Args)
+    module PSU = PseudoFunctorialityUnbiasedPadding (EHArgs)
+
+    let eh =
+      let open EHCtx (EHArgs) in
+      let step1 =
+        let p = BP.p in
+        let a_padded =
+          Construct.(
+            tm_app_sub p
+              (Unchecked.sub_ps_to_sub (characteristic_sub_ps a_constr)))
+        in
+        let b_padded =
+          Construct.(
+            tm_app_sub
+              (Opposite.checked_tm p [ 1 ])
+              (Unchecked.sub_ps_to_sub (characteristic_sub_ps b_constr)))
+        in
+        (* TODO: there should be a fix here so that there is no need for the develop *)
+        Construct.(develop (wcomp a_padded (Args.n - 1) b_padded))
+      in
+      let step2 =
+        let r = BToU.repadded in
+        let r_op = Opposite.checked_tm r [ 1 ] in
+        let repad_a = Construct.tm_app r a_comp_id_sub in
+        let repad_b = Construct.tm_app r_op id_comp_b_sub in
+        Construct.wcomp repad_a (Args.n - 1) repad_b
+      in
+      let step3 =
+        Construct.tm_app PSU.psfpad [ id_comp_b; a_comp_id; x_constr ]
+      in
+      let step4 =
+        let intch = Construct.coh_app (intch Args.n) [ a_constr; b_constr ] in
+        Construct.tm_app
+          (Functorialisation.tm UP.padded [ (UP.v, 1) ])
+          [ intch; Construct.tgt 1 intch; Construct.src 1 intch; x_constr ]
+      in
+      Construct.comp_n [ step1; step2; step3; step4 ]
+  end
+
+  module LT (Args : BiasedPaddingArgsS) = struct
+    module FP = ForwardBiasedPadding (Args)
+    module FToU = ForwardToUnbiasedRepadding (Args)
+    module PSU = PseudoFunctorialityUnbiasedPadding (EHArgs)
+
+    let eh =
+      let open EHCtx (EHArgs) in
+      let a_sub =
+        Unchecked.sub_ps_to_sub (Construct.characteristic_sub_ps a_constr)
+      in
+      let b_sub =
+        Unchecked.sub_ps_to_sub (Construct.characteristic_sub_ps b_constr)
+      in
+      let step1 =
+        Construct.inverse
+          (Construct.coh_app (intch Args.n) [ a_constr; b_constr ])
+      in
+      let step2 =
+        let p = FP.p in
+        let a_padded = Construct.tm_app_sub p a_sub in
+        let b_padded =
+          Construct.(tm_app_sub (Opposite.checked_tm p [ 1 ]) b_sub)
+        in
+        Construct.(develop (wcomp a_padded (Args.n - 1) b_padded))
+      in
+      let step3 =
+        let r = FToU.repadded in
+        let r_op = Opposite.checked_tm r [ 1 ] in
+        let repad_a = Construct.tm_app r [ a_constr; x_constr ] in
+        let repad_b = Construct.tm_app r_op [ b_constr; x_constr ] in
+        Construct.wcomp repad_a (Args.n - 1) repad_b
+      in
+      let step4 =
+        Construct.tm_app PSU.psfpad [ b_constr; a_constr; x_constr ]
+      in
+      Construct.comp_n [ step1; step2; step3; step4 ]
+  end
+end
+
+let suspend eh_prev curargs =
+  let module EHArgs = (val curargs : EHArgsS) in
+  let open EHCtx (EHArgs) in
+  let module R = SuspUnbiasedToUnbiasedRepadding (EHArgs) in
+  let suspended_eh = Suspension.checked_tm (Some 1) eh_prev in
+  Construct.comp_n
+    [
+      Construct.tm_app suspended_eh
+        [ b_constr; a_constr; Construct.id x_constr; x_constr; x_constr ];
+      Construct.tm_app R.repadded
+        [ Construct.wcomp a_constr EHArgs.l b_constr; x_constr ];
+    ]
+
+module Naturality = struct
+  let nat_unitor constr =
+    let x_constr = (Var (Var.Db 0), Obj) in
+    let y_constr = (Var (Var.Db 1), Obj) in
+    let f_constr = (Var (Var.Db 2), Construct.arr x_constr y_constr) in
+    let cohty =
+      Construct.arr f_constr
+        (Construct.comp_n [ f_constr; Construct.id_n 1 y_constr ])
+    in
+    let runit = check_coh (Unchecked.disc 1) cohty ("_ehnat_step1", 0, []) in
+    let d = Construct.dim constr in
+    let sub = Construct.characteristic_sub_ps constr in
+    ( Coh (Suspension.coh (Some (d - 1)) runit, sub),
+      Unchecked.ty_apply_sub_ps (Suspension.ty (Some (d - 1)) cohty) sub )
+
+  let nat_factor eh_id_id ehargs =
+    let module EHArgs = (val ehargs : EHArgsS) in
+    let open EHCtx (EHArgs) in
+    let idn = Construct.id id in
+    let ty =
+      Construct.arr
+        (Construct.id (Construct.wcomp idn EHArgs.k idn))
+        (Construct.comp_n [ eh_id_id; Tm.constr UP.q ])
+    in
+
+    let name =
+      (Printf.sprintf "_factor_id(%d,%d,%d)" EHArgs.n EHArgs.k EHArgs.l, 0, [])
+    in
+    let coh = check_coh (Unchecked.disc 0) ty name in
+    Construct.of_coh coh
+
+  let nat_associator1 c1 c2 c3 =
+    let open Builtin.Comp in
+    let ty =
+      Construct.arr
+        (Construct.comp_n [ f 1; Construct.comp_n [ f 2; f 3 ] ])
+        (Construct.comp_n [ Construct.comp_n [ f 1; f 2 ]; f 3 ])
+    in
+    let coh = check_coh (tree 3) ty ("_assoc_left", 0, []) in
+    let d = Construct.dim c1 in
+    Construct.coh_app (Suspension.coh (Some (d - 1)) coh) [ c1; c2; c3 ]
+
+  let nat_associator2 c1 c2 c3 =
+    let open Builtin.Comp in
+    let ty =
+      Construct.arr
+        (Construct.comp_n [ Construct.comp_n [ f 1; f 2 ]; f 3 ])
+        (Construct.comp_n [ f 1; f 2; f 3 ])
+    in
+    let coh = check_coh (tree 3) ty ("_unbiasor_left", 0, []) in
+    let d = Construct.dim c1 in
+    Construct.coh_app (Suspension.coh (Some (d - 1)) coh) [ c1; c2; c3 ]
+
+  let nat_finalcoh eh_id_id ehargs =
+    let module EHArgs = (val ehargs : EHArgsS) in
+    let open EHCtx (EHArgs) in
+    let module UP = UnbiasedPadding (EHArgs) in
+    let p = Tm.constr UP.p in
+    let ty = Construct.arr eh_id_id p in
+    let name =
+      (Printf.sprintf "_eh_to_p(%d,%d,%d)" EHArgs.n EHArgs.k EHArgs.l, 0, [])
+    in
+    let coh = check_coh (Unchecked.disc 0) ty name in
+    Construct.of_coh coh
+
+  let compute eh_prev prev_args args =
+    let module PrevArgs = (val prev_args : EHArgsS) in
+    let open PrevArgs in
+    let module NextArgs = (val args : EHArgsS) in
+    let open EHCtx (NextArgs) in
+    let module Prev = EHCtx (PrevArgs) in
+    let module UP = UnbiasedPadding (PrevArgs) in
+    let q = Tm.constr UP.q in
+    let a_k_b = Construct.wcomp a_constr k b_constr in
+    let nat =
+      Construct.inverse
+        (Construct.tm_app
+           (Functorialisation.tm eh_prev [ (Prev.b, 1); (Prev.a, 1) ])
+           [ b_constr; id; id; a_constr; id; id; x_constr ])
+    in
+    let paddedfunc =
+      Construct.tm_app
+        (Functorialisation.tm UP.padded [ (UP.v, 1) ])
+        [
+          Construct.wcomp a_constr l b_constr;
+          UP.F.tgt_v (n + 1);
+          UP.F.src_v (n + 1);
+          x_constr;
+        ]
+    in
+    let eh_id_id = Construct.tm_app eh_prev [ id; id; x_constr ] in
+    Construct.comp_n
+      [
+        nat_unitor a_k_b;
+        Construct.wcomp a_k_b n (nat_factor eh_id_id prev_args);
+        nat_associator1 a_k_b eh_id_id q;
+        Construct.wcomp nat n q;
+        nat_associator2 eh_id_id paddedfunc q;
+        Construct.wcomp3 (nat_finalcoh eh_id_id prev_args) n paddedfunc n q;
+      ]
+end
+
+let rec eh nkl =
+  let module EHArgs = (val nkl : EHArgsS) in
+  let open EHArgs in
+  let module BArgs = (val args_biased n) in
+  let eh_constr =
+    if k = 0 && l = n - 1 then
+      let module BaseCases = BaseCases (EHArgs) in
+      let module BaseCase = BaseCases.LT (BArgs) in
+      BaseCase.eh
+    else if k = n - 1 && l = 0 then
+      let module BaseCases = BaseCases (EHArgs) in
+      let module BaseCase = BaseCases.GT (BArgs) in
+      BaseCase.eh
+    else if max k l = n - 1 then
+      let prevargs = args (n - 1) (k - 1) (l - 1) in
+      suspend (eh prevargs) nkl
+    else
+      let prevargs = args (n - 1) k l in
+      Naturality.compute (eh prevargs) prevargs nkl
+  in
+  let module C = EHCtx (EHArgs) in
+  check_constr C.ctx
+    ~name:(Printf.sprintf "eh^%d_(%d,%d)" n k l, 0, [])
+    eh_constr
+
+let full_eh nkl =
+  let eh = eh nkl in
+  let open (val nkl) in
+  let open EHCtx ((val nkl)) in
+  let constr =
+    Construct.comp_n
+      [
+        Construct.of_tm eh;
+        Construct.tm_app
+          (Inverse.inverse (Opposite.checked_tm eh [ l + 1 ]))
+          [ a_constr; b_constr; x_constr ];
+      ]
+  in
+  check_constr ctx constr
+
+let eh n k l = eh (args n k l)
+let full_eh n k l = full_eh (args n k l)
diff --git a/lib/eh.mli b/lib/eh.mli
new file mode 100644
index 00000000..44aab184
--- /dev/null
+++ b/lib/eh.mli
@@ -0,0 +1,4 @@
+open Kernel
+
+val eh : int -> int -> int -> Tm.t
+val full_eh : int -> int -> int -> Tm.t
diff --git a/lib/environment.ml b/lib/environment.ml
index 6a7d8665..c9501f78 100644
--- a/lib/environment.ml
+++ b/lib/environment.ml
@@ -12,6 +12,8 @@ let builtin_to_value b =
   | Conecomp (n, k, m) -> Tm (Cones.compose n m k)
   | Cylcomp (n, k, m) -> Tm (Cylinders.compose n m k)
   | Cylstack n -> Tm (Cylinders.stacking n)
+  | Eh_half (n, k, l) -> Tm (Eh.eh n k l)
+  | Eh_full (n, k, l) -> Tm (Eh.full_eh n k l)
 
 let value_ty v =
   match v with
diff --git a/lib/lexer.mll b/lib/lexer.mll
index 49717a32..5f358713 100644
--- a/lib/lexer.mll
+++ b/lib/lexer.mll
@@ -24,6 +24,16 @@ rule token = parse
   | "cylstack(" (['0'-'9']* as n) ")" {
                                       let n = int_of_string n in
                                       CYLSTACK(n) }
+  | "EH(" (['0'-'9']* as n) "," (['0'-'9']* as k) "," (['0'-'9']* as l)")" {
+                                                                            let n = int_of_string n in
+                                                                            let k = int_of_string k in
+                                                                            let l = int_of_string l in
+                                                                            EH_FULL(n,k,l) }
+  | "eh(" (['0'-'9']* as n) "," (['0'-'9']* as k) "," (['0'-'9']* as l)")" {
+                                                                            let n = int_of_string n in
+                                                                            let k = int_of_string k in
+                                                                            let l = int_of_string l in
+                                                                            EH_HALF(n,k,l) }                                                                        
   | "declare" { DECLARE }
   | "I" { INV }
   | "U" { UNIT }
diff --git a/lib/parser.mly b/lib/parser.mly
index 9cb03c6d..f49ac81a 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -37,6 +37,8 @@
 %token <string> BUILTIN
 %token <int*int*int> CONECOMP
 %token <int*int*int> CYLCOMP
+%token <int*int*int> EH_FULL
+%token <int*int*int> EH_HALF
 %token <int> CYLSTACK
 %token <string> IDENT
 %token <string> INT
@@ -114,6 +116,8 @@ builtin:
  | CONECOMP { let (n,k,m) = $1 in Conecomp(n,k,m) }
  | CYLCOMP { let (n,k,m) = $1 in Cylcomp(n,k,m) }
  | CYLSTACK { let n = $1 in Cylstack(n) }
+ | EH_HALF { let (n,k,l) = $1 in Eh_half(n,k,l)}
+ | EH_FULL { let (n,k,l) = $1 in Eh_full(n,k,l)}
 
 simple_tmexpr:
   | LPAR tmexpr RPAR { $2 }
diff --git a/lib/raw.ml b/lib/raw.ml
index f2dba944..b2dfa1dc 100644
--- a/lib/raw.ml
+++ b/lib/raw.ml
@@ -8,6 +8,8 @@ let string_of_builtin = function
   | Conecomp (n, k, m) -> Printf.sprintf "conecomp(%d,%d,%d)" n k m
   | Cylcomp (n, k, m) -> Printf.sprintf "cylcomp(%d,%d,%d)" n k m
   | Cylstack n -> Printf.sprintf "cylstack(%d)" n
+  | Eh_half (n , k , l) -> Printf.sprintf "eh^%d_(%d,%d)" n k l
+  | Eh_full (n , k , l) -> Printf.sprintf "EH^%d_(%d,%d)" n k l
 
 let rec string_of_ty e =
   match e with
@@ -124,6 +126,7 @@ and dim_builtin = function
   | Id -> 1
   | Conecomp (n, _, m) | Cylcomp (n, _, m) -> max n m
   | Cylstack n -> n
+  | Eh_half (n, _, _) | Eh_full (n, _, _) -> n + 1
 
 let rec dim_sub ctx = function
   | [] -> (0, 0)
@@ -145,7 +148,8 @@ let rec infer_susp_tm ctx = function
                 match b with
                 | Comp -> 1
                 | Id -> 0
-                | Conecomp (n, _, _) | Cylcomp (n, _, _) | Cylstack n -> n)
+                | Conecomp (n, _, _) | Cylcomp (n, _, _) | Cylstack n -> n
+                | Eh_half (n, _, _) | Eh_full (n, _, _) -> n)
             | _ -> assert false
           in
           let d, func = dim_sub ctx s in
diff --git a/lib/raw_types.mli b/lib/raw_types.mli
index a700082a..908d2d71 100644
--- a/lib/raw_types.mli
+++ b/lib/raw_types.mli
@@ -6,6 +6,8 @@ type builtin =
   | Conecomp of (int * int * int)
   | Cylcomp of (int * int * int)
   | Cylstack of int
+  | Eh_half of (int * int * int)
+  | Eh_full of (int * int * int)
 
 type tyR = Letin_ty of Var.t * tmR * tyR | ObjR | ArrR of tmR * tmR
 
diff --git a/lib/translate_raw.ml b/lib/translate_raw.ml
index 66b303f8..d1ce4f3f 100644
--- a/lib/translate_raw.ml
+++ b/lib/translate_raw.ml
@@ -60,6 +60,12 @@ let rec tm t =
           make_app tm s susp expl
       | Cylstack n ->
           let tm = Cylinders.stacking n in
+          make_app tm s susp expl
+      | Eh_half (n, k, l) ->
+          let tm = Eh.eh n k l in
+          make_app tm s susp expl
+      | Eh_full (n, k, l) ->
+          let tm = Eh.full_eh n k l in
           make_app tm s susp expl)
   | Op (l, t) ->
       let offset = head_susp t in

From 113fc5b5dbb3aedc4ac8619b0b01eb8a875bd839 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Mon, 8 Sep 2025 17:03:20 +0200
Subject: [PATCH 04/30] update CHANGES.md

---
 CHANGES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGES.md b/CHANGES.md
index 7c91b4b7..0c830101 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,4 +1,5 @@
 ## Catt
+- Computation of Eckmann-Hilton cells as a builtin
 - Improve efficiency by storing partially checked terms
 - Computation of cylinder compositions as a builtin
 - Computation of cone compositions as a builtin

From 89cd2f2955141ae8a2ea461135e8b4fd83f29cd8 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Mon, 8 Sep 2025 17:25:27 +0200
Subject: [PATCH 05/30] add tests

---
 test.t/features/eh.catt |  15 ++++++
 test.t/run.t            | 104 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 119 insertions(+)
 create mode 100644 test.t/features/eh.catt

diff --git a/test.t/features/eh.catt b/test.t/features/eh.catt
new file mode 100644
index 00000000..5b2f000a
--- /dev/null
+++ b/test.t/features/eh.catt
@@ -0,0 +1,15 @@
+check eh(2,0,1)
+check eh(3,0,1)
+check eh(4,2,1)
+check eh(3,1,2)
+check eh(4,3,2)
+check eh(3,1,2)
+check eh(4,2,3)
+check eh(3,0,2)
+check eh(2,1,0)
+check eh(3,2,0)
+check EH(2,0,1)
+check EH(3,0,1)
+check EH(3,1,2)
+check EH(3,1,2)
+check EH(3,2,0)
diff --git a/test.t/run.t b/test.t/run.t
index f7eb3036..f605911b 100644
--- a/test.t/run.t
+++ b/test.t/run.t
@@ -667,3 +667,107 @@
   [=I.I=] successfully defined term (!1builtin_comp3 [(Ilsimp x)] [(!2builtin_comp2 (!1builtin_comp3 (builtin_comp2 (builtin_id x) [a]) [(!2builtin_comp2 (!1builtin_comp2 [(lsimp x)] [(Ilsimp_op{1} x)]) (unit_Unit x))] (builtin_comp2 [b] (builtin_id x))) (exch b a))] [(lsimp_op{1} x)]) of type (!1builtin_comp3 (unitl^-1 (builtin_id x)) (!1builtin_comp3 (builtin_comp2 (builtin_id x) [a]) (!1builtin_comp2 (unitl (builtin_id x)) (unitl_op{1}^-1 (builtin_id x))) (builtin_comp2 [b] (builtin_id x))) (unitl_op{1} (builtin_id x))) -> (!1builtin_comp3 (unit^-1 x) (builtin_comp2 [b] [a]) (unit_op{1} x)).
   [=^.^=] let eh = (_builtin_comp  (eh1  a b) (eh2  a b) I(op_{1}((eh2  b a))) I(op_{1}((eh1  b a))))
   [=I.I=] successfully defined term (!2builtin_comp4 (eh1 a b) (eh2 a b) (!1builtin_comp3 [(Ilsimp_op{1}^-1 x)] [(!2builtin_comp2 (exch_op{1}^-1 b a) (!1builtin_comp3 (builtin_comp2_func[(.6,1)]_op{1} (builtin_id x) b) [(!2builtin_comp2 (unit_Unit_op{1}^-1 x) (!1builtin_comp2 [(lsimp_op{1}^-1 x)] [(Ilsimp_op{1}_op{1}^-1 x)]))] (builtin_comp2_func[(.4,1)]_op{1} a (builtin_id x))))] [(lsimp_op{1}_op{1}^-1 x)]) (eh1_op{1}^-1 b a)) of type (!1builtin_comp2 a b) -> (!1builtin_comp2_op{1} b a).
+
+  $ catt --no-builtins features/cones.catt
+  [=^.^=] check conecomp(2,1,2)
+  [=I.I=] valid term builtin_conecomp(2,1,2) of type .4 -> (builtin_comp2 (builtin_comp2 .2 .8) .9).
+  [=^.^=] check conecomp(3,1,3)
+  [=I.I=] valid term builtin_conecomp(3,1,3) of type (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .8 (builtin_comp2 .2 [.16])) (assoc .2 .12 .15)) (builtin_comp2 [(builtin_comp2 [.4] [.14])] .15)) -> (!1builtin_comp2 (!1builtin_comp2 .9 (builtin_comp2 .3 [.17])) (assoc .3 .13 .15)).
+  [=^.^=] check conecomp(3,2,3)
+  [=I.I=] valid term builtin_conecomp(3,2,3) of type (!1builtin_comp2 .8 (builtin_comp2 [(!1builtin_comp2 .4 .12)] .7)) -> .13.
+  [=^.^=] check conecomp(3,1,2)
+  [=I.I=] valid term builtin_conecomp(3,1,2) of type (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .8 (builtin_comp2 .2 [.14])) (assoc .2 .12 .13)) (builtin_comp2 [(builtin_comp2 [.4] .12)] .13)) -> (!1builtin_comp2 (!1builtin_comp2 .9 (builtin_comp2 .3 [.14])) (assoc .3 .12 .13)).
+  [=^.^=] check conecomp(2,1,3)
+  [=I.I=] valid term builtin_conecomp(2,1,3) of type (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .6 (builtin_comp2 .2 [.12])) (assoc .2 .8 .11)) (builtin_comp2 [(builtin_comp2 .2 [.10])] .11)) -> (!1builtin_comp2 (!1builtin_comp2 .6 (builtin_comp2 .2 [.13])) (assoc .2 .9 .11)).
+  [=^.^=] check conecomp(4,1,4)
+  [=I.I=] valid term builtin_conecomp(4,1,4) of type (!2builtin_comp3 (intch_src (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (assoc .2 .16 .21) (builtin_comp2 [(builtin_comp2 [.4] [.18])] .21)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (assoc .2 .16 .21) (builtin_comp2 [(builtin_comp2 [.4] [.18])] .21)) (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) [(assoc [.4] [.18] .21)]) (!1assoc (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (builtin_comp2 [.4] [(builtin_comp2 [.18] .21)]) (assoc .3 .17 .21)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.12] [_] [(@builtin_comp2_func[(.6,1)] _ _ [.4] _ _ [_] [.24])])] (assoc .3 .17 .21)))]) (intch_tgt .8 (!1builtin_comp2 .11 (builtin_comp2 .3 [.23])) (assoc .3 .17 .21))) -> (!2builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (assoc .2 .16 .21)) [(builtin_comp2 [[(builtin_comp2 [[.6]] [[.20]])]] .21)]) (!2builtin_comp3 (intch_src (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (assoc .2 .16 .21) (builtin_comp2 [(builtin_comp2 [.5] [.19])] .21)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (assoc .2 .16 .21) (builtin_comp2 [(builtin_comp2 [.5] [.19])] .21)) (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) [(assoc [.5] [.19] .21)]) (!1assoc (!1builtin_comp2 .10 (builtin_comp2 .2 [.22])) (builtin_comp2 [.5] [(builtin_comp2 [.19] .21)]) (assoc .3 .17 .21)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.13] [_] [(@builtin_comp2_func[(.6,1)] _ _ [.5] _ _ [_] [.25])])] (assoc .3 .17 .21)))]) (intch_tgt .8 (!1builtin_comp2 .11 (builtin_comp2 .3 [.23])) (assoc .3 .17 .21)))).
+  [=^.^=] check conecomp(4,2,4)
+  [=I.I=] valid term builtin_conecomp(4,2,4) of type (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp_1_0_intch .4 .16 .9)]) (!2builtin_comp2 (!1assoc .10 (builtin_comp2 [.4] .9) (builtin_comp2 [.16] .9)) (!1!1builtin_comp2_op{1,2} .20 (!1builtin_comp2_func[(.6,1)]_op{1,2} (builtin_comp2 [.16] .9) .12)))) -> (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp2 [[(!1builtin_comp2 [.6] [.18])]] .9)]) (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp_1_0_intch .5 .17 .9)]) (!2builtin_comp2 (!1assoc .10 (builtin_comp2 [.5] .9) (builtin_comp2 [.17] .9)) (!1!1builtin_comp2_op{1,2} .21 (!1builtin_comp2_func[(.6,1)]_op{1,2} (builtin_comp2 [.17] .9) .13))))).
+  [=^.^=] check conecomp(4,3,4)
+  [=I.I=] valid term builtin_conecomp(4,3,4) of type .12 -> (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp2 [[(!2builtin_comp2 .6 .16)]] .9)]) .17).
+  [=^.^=] check conecomp(4,1,2)
+  [=I.I=] valid term builtin_conecomp(4,1,2) of type (!2builtin_comp3 (intch_src (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (assoc .2 .16 .17) (builtin_comp2 [(builtin_comp2 [.4] .16)] .17)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (assoc .2 .16 .17) (builtin_comp2 [(builtin_comp2 [.4] .16)] .17)) (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) [(assoc [.4] .16 .17)]) (!1assoc (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (builtin_comp2 [.4] (builtin_comp2 .16 .17)) (assoc .3 .16 .17)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.12] [_] [(builtin_comp2_func[(.8,1)] [.4] .18)])] (assoc .3 .16 .17)))]) (intch_tgt .8 (!1builtin_comp2 .11 (builtin_comp2 .3 [.18])) (assoc .3 .16 .17))) -> (!2builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (assoc .2 .16 .17)) [(builtin_comp2 [[(builtin_comp2 [[.6]] .16)]] .17)]) (!2builtin_comp3 (intch_src (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (assoc .2 .16 .17) (builtin_comp2 [(builtin_comp2 [.5] .16)] .17)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (assoc .2 .16 .17) (builtin_comp2 [(builtin_comp2 [.5] .16)] .17)) (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) [(assoc [.5] .16 .17)]) (!1assoc (!1builtin_comp2 .10 (builtin_comp2 .2 [.18])) (builtin_comp2 [.5] (builtin_comp2 .16 .17)) (assoc .3 .16 .17)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.13] [_] [(builtin_comp2_func[(.8,1)] [.5] .18)])] (assoc .3 .16 .17)))]) (intch_tgt .8 (!1builtin_comp2 .11 (builtin_comp2 .3 [.18])) (assoc .3 .16 .17)))).
+  [=^.^=] check conecomp(4,1,3)
+  [=I.I=] valid term builtin_conecomp(4,1,3) of type (!2builtin_comp3 (intch_src (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (assoc .2 .16 .19) (builtin_comp2 [(builtin_comp2 [.4] [.18])] .19)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (assoc .2 .16 .19) (builtin_comp2 [(builtin_comp2 [.4] [.18])] .19)) (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) [(assoc [.4] [.18] .19)]) (!1assoc (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (builtin_comp2 [.4] [(builtin_comp2 [.18] .19)]) (assoc .3 .17 .19)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.12] [_] [(@builtin_comp2_func[(.6,1)] _ _ [.4] _ _ [_] [.22])])] (assoc .3 .17 .19)))]) (intch_tgt .8 (!1builtin_comp2 .11 (builtin_comp2 .3 [.21])) (assoc .3 .17 .19))) -> (!2builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (assoc .2 .16 .19)) [(builtin_comp2 [[(builtin_comp2 [[.6]] [.18])]] .19)]) (!2builtin_comp3 (intch_src (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (assoc .2 .16 .19) (builtin_comp2 [(builtin_comp2 [.5] [.18])] .19)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (assoc .2 .16 .19) (builtin_comp2 [(builtin_comp2 [.5] [.18])] .19)) (!1builtin_comp2 (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) [(assoc [.5] [.18] .19)]) (!1assoc (!1builtin_comp2 .10 (builtin_comp2 .2 [.20])) (builtin_comp2 [.5] [(builtin_comp2 [.18] .19)]) (assoc .3 .17 .19)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.13] [_] [(@builtin_comp2_func[(.6,1)] _ _ [.5] _ _ [_] [.22])])] (assoc .3 .17 .19)))]) (intch_tgt .8 (!1builtin_comp2 .11 (builtin_comp2 .3 [.21])) (assoc .3 .17 .19)))).
+  [=^.^=] check conecomp(2,1,4)
+  [=I.I=] valid term builtin_conecomp(2,1,4) of type (!2builtin_comp3 (intch_src (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (assoc .2 .8 .13) (builtin_comp2 [(builtin_comp2 .2 [.10])] .13)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (assoc .2 .8 .13) (builtin_comp2 [(builtin_comp2 .2 [.10])] .13)) (!1builtin_comp2 (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) [(assoc .2 [.10] .13)]) (!1assoc (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (builtin_comp2 .2 [(builtin_comp2 [.10] .13)]) (assoc .2 .9 .13)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ _ .6 [_] [(@builtin_comp2_func[(.6,1)] _ _ .2 _ _ [_] [.16])])] (assoc .2 .9 .13)))]) (intch_tgt .4 (!1builtin_comp2 .6 (builtin_comp2 .2 [.15])) (assoc .2 .9 .13))) -> (!2builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (assoc .2 .8 .13)) [(builtin_comp2 [[(builtin_comp2 .2 [[.12]])]] .13)]) (!2builtin_comp3 (intch_src (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (assoc .2 .8 .13) (builtin_comp2 [(builtin_comp2 .2 [.11])] .13)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (assoc .2 .8 .13) (builtin_comp2 [(builtin_comp2 .2 [.11])] .13)) (!1builtin_comp2 (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) [(assoc .2 [.11] .13)]) (!1assoc (!1builtin_comp2 .6 (builtin_comp2 .2 [.14])) (builtin_comp2 .2 [(builtin_comp2 [.11] .13)]) (assoc .2 .9 .13)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ _ .6 [_] [(@builtin_comp2_func[(.6,1)] _ _ .2 _ _ [_] [.17])])] (assoc .2 .9 .13)))]) (intch_tgt .4 (!1builtin_comp2 .6 (builtin_comp2 .2 [.15])) (assoc .2 .9 .13)))).
+  [=^.^=] check conecomp(3,1,4)
+  [=I.I=] valid term builtin_conecomp(3,1,4) of type (!2builtin_comp3 (intch_src (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (assoc .2 .12 .17) (builtin_comp2 [(builtin_comp2 [.4] [.14])] .17)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (assoc .2 .12 .17) (builtin_comp2 [(builtin_comp2 [.4] [.14])] .17)) (!1builtin_comp2 (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) [(assoc [.4] [.14] .17)]) (!1assoc (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (builtin_comp2 [.4] [(builtin_comp2 [.14] .17)]) (assoc .3 .13 .17)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.10] [_] [(@builtin_comp2_func[(.6,1)] _ _ [.4] _ _ [_] [.20])])] (assoc .3 .13 .17)))]) (intch_tgt .6 (!1builtin_comp2 .9 (builtin_comp2 .3 [.19])) (assoc .3 .13 .17))) -> (!2builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (assoc .2 .12 .17)) [(builtin_comp2 [[(builtin_comp2 [.4] [[.16]])]] .17)]) (!2builtin_comp3 (intch_src (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (assoc .2 .12 .17) (builtin_comp2 [(builtin_comp2 [.4] [.15])] .17)) (!1builtin_comp2_red [(!2builtin_comp4 (!1builtin_assc (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (assoc .2 .12 .17) (builtin_comp2 [(builtin_comp2 [.4] [.15])] .17)) (!1builtin_comp2 (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) [(assoc [.4] [.15] .17)]) (!1assoc (!1builtin_comp2 .8 (builtin_comp2 .2 [.18])) (builtin_comp2 [.4] [(builtin_comp2 [.15] .17)]) (assoc .3 .13 .17)) (!1builtin_comp2 [(@!1builtin_comp2 _ _ _ [_] [.10] [_] [(@builtin_comp2_func[(.6,1)] _ _ [.4] _ _ [_] [.21])])] (assoc .3 .13 .17)))]) (intch_tgt .6 (!1builtin_comp2 .9 (builtin_comp2 .3 [.19])) (assoc .3 .13 .17)))).
+  [=^.^=] check conecomp(4,2,3)
+  [=I.I=] valid term builtin_conecomp(4,2,3) of type (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp_1_0_intch .4 .16 .9)]) (!2builtin_comp2 (!1assoc .10 (builtin_comp2 [.4] .9) (builtin_comp2 [.16] .9)) (!1!1builtin_comp2_op{1,2} .18 (!1builtin_comp2_func[(.6,1)]_op{1,2} (builtin_comp2 [.16] .9) .12)))) -> (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp2 [[(!1builtin_comp2 [.6] .16)]] .9)]) (!2builtin_comp2 (!1builtin_comp2 .10 [(builtin_comp_1_0_intch .5 .16 .9)]) (!2builtin_comp2 (!1assoc .10 (builtin_comp2 [.5] .9) (builtin_comp2 [.16] .9)) (!1!1builtin_comp2_op{1,2} .18 (!1builtin_comp2_func[(.6,1)]_op{1,2} (builtin_comp2 [.16] .9) .13))))).
+  [=^.^=] check conecomp(3,2,4)
+  [=I.I=] valid term builtin_conecomp(3,2,4) of type (!2builtin_comp2 (!1builtin_comp2 .8 [(builtin_comp_1_0_intch .4 .12 .7)]) (!2builtin_comp2 (!1assoc .8 (builtin_comp2 [.4] .7) (builtin_comp2 [.12] .7)) (!1!1builtin_comp2_op{1,2} .16 (!1builtin_comp2_func[(.6,1)]_op{1,2} (builtin_comp2 [.12] .7) .10)))) -> (!2builtin_comp2 (!1builtin_comp2 .8 [(builtin_comp2 [[(!1builtin_comp2 .4 [.14])]] .7)]) (!2builtin_comp2 (!1builtin_comp2 .8 [(builtin_comp_1_0_intch .4 .13 .7)]) (!2builtin_comp2 (!1assoc .8 (builtin_comp2 [.4] .7) (builtin_comp2 [.13] .7)) (!1!1builtin_comp2_op{1,2} .17 (!1builtin_comp2_func[(.6,1)]_op{1,2} (builtin_comp2 [.13] .7) .10))))).
+
+  $ catt --no-builtins features/cylinders.catt
+  [=^.^=] check cylcomp(2,1,2)
+  [=I.I=] valid term builtin_conecomp(2,1,2) of type (builtin_comp2 (builtin_comp2 .2 .10) .13) -> (builtin_comp2 .6 (builtin_comp2 .5 .12)).
+  [=^.^=] check cylcomp(3,1,3)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.26,1) (.22,1) (.18,1) (.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .18)] .23) (!1builtin_comp3 (intch_src_op{3} .3 .17 .23) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .23) (builtin_comp2_op{2} .3 [.25]) (assoc_op{3} .3 .11 .21) (builtin_comp2_op{2} [.13] .21) (builtin_assc_op{3} .10 .8 .21))) (intch_tgt_op{3} .10 .8 .21))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .23) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .23) (builtin_comp2_op{2} .2 [.24]) (assoc_op{3} .2 .11 .20) (builtin_comp2_op{2} [.12] .20) (builtin_assc_op{3} .10 .7 .20))) (intch_tgt_op{3} .10 .7 .20)) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .22)])).
+  [=^.^=] check cylcomp(3,2,3)
+  [=D.D=] substitution: (.0, .0) (.1, .6) (.2, (builtin_comp2 .2 .11)) (.3, (builtin_comp2 .3 .11)) (.4, (builtin_comp2 [.4] .11)) (.5, (builtin_comp2 .10 .7)) (.6, (builtin_comp2 .10 .8)) (.7, (builtin_comp2 .10 [.9])) (.8, .12) (.9, .13) (.10, .14) (.11, (builtin_comp2 .15 .11)) (.12, (builtin_comp2 [.16] .11)) (.13, (builtin_comp2 .10 .17)) (.14, (builtin_comp2 .10 [.18])) (.15, .19) (.16, .20)
+  
+  [=I.I=] valid term builtin_conecomp(3,2,3) of type (!1builtin_comp2 (builtin_comp2 [(!1builtin_comp2 .4 .16)] .11) .19) -> (!1builtin_comp2 .12 (builtin_comp2_func[(.4,1)]_op{1} (!1builtin_comp2 .9 .18) .10)).
+  [=^.^=] check cylcomp(3,1,2)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .16)] .19) (!1builtin_comp3 (intch_src_op{3} .3 .16 .19) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .16 .19) (builtin_comp2_op{2} .3 [.20]) (assoc_op{3} .3 .11 .18) (builtin_comp2_op{2} [.13] .18) (builtin_assc_op{3} .10 .8 .18))) (intch_tgt_op{3} .10 .8 .18))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .19) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .19) (builtin_comp2_op{2} .2 [.20]) (assoc_op{3} .2 .11 .18) (builtin_comp2_op{2} [.12] .18) (builtin_assc_op{3} .10 .7 .18))) (intch_tgt_op{3} .10 .7 .18)) (builtin_comp2_op{2} .10 [(builtin_comp2_op{2} [.9] .18)])).
+  [=^.^=] check cylcomp(2,1,3)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.20,1) (.16,1) (.12,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.12])] .17) (!1builtin_comp3 (intch_src_op{3} .2 .11 .17) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .17) (builtin_comp2_op{2} .2 [.19]) (assoc_op{3} .2 .7 .15) (builtin_comp2_op{2} [.8] .15) (builtin_assc_op{3} .6 .5 .15))) (intch_tgt_op{3} .6 .5 .15))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .10 .17) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .17) (builtin_comp2_op{2} .2 [.18]) (assoc_op{3} .2 .7 .14) (builtin_comp2_op{2} [.8] .14) (builtin_assc_op{3} .6 .5 .14))) (intch_tgt_op{3} .6 .5 .14)) (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.16])])).
+  [=^.^=] check cylcomp(4,1,4)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.26,1) (.22,1) (.18,1) (.14,1) (.9,1) (.4,1)]_op{3}_func[(.38,1) (.32,1) (.26,1) (.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.4,1) (.8,1)]_op{3} [.6] [.26]) .33)] (!1builtin_comp3 (intch_src_op{3} .3 .23 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .5 .25)] .33) (intch_src_op{3} .3 .23 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .5 .25)] .33) (intch_src_op{3} .3 .23 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp3 [(intch_src_func[(.4,1) (.8,1)]_op{3} .5 .25 .33)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .5 .25)] .33)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .33) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1) (.8,1)]_op{3} .5 .25 .33) (builtin_comp2_func[(.6,1)][(.2~,1) (.4~,1) (.5~,1) (.6~,1)]_op{3} .5 .37) (assoc_func[(.4,1) (.10,1)]_op{3} .5 .15 .31) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1) (.6~,1)]_op{3} .19 .31) (builtin_assc_func[(.6,1) (.10,1)]_op{3} .14 .12 .31)))] (intch_tgt_op{3} .14 .10 .29)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .12 .31)])) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) [(intch_tgt_func[(.6,1) (.10,1)]_op{3} .14 .12 .31)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (intch_tgt_op{3} .14 .9 .28) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .12 .31)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (intch_tgt_op{3} .14 .9 .28) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .12 .31)])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .24)] .33) (intch_src_op{3} .3 .23 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .24)] .33) (intch_src_op{3} .3 .23 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp3 [(intch_src_func[(.4,1) (.8,1)]_op{3} .4 .24 .33)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .24)] .33)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .33) (builtin_comp2_op{2} .3 [.35]) (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29))) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .33) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1) (.8,1)]_op{3} .4 .24 .33) (builtin_comp2_func[(.6,1)][(.2~,1) (.4~,1) (.5~,1) (.6~,1)]_op{3} .4 .36) (assoc_func[(.4,1) (.10,1)]_op{3} .4 .15 .30) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1) (.6~,1)]_op{3} .18 .30) (builtin_assc_func[(.6,1) (.10,1)]_op{3} .14 .11 .30)))] (intch_tgt_op{3} .14 .10 .29)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .11 .30)])) (intch_tgt_op{3} .14 .10 .29)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) [(intch_tgt_func[(.6,1) (.10,1)]_op{3} .14 .11 .30)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (intch_tgt_op{3} .14 .9 .28) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .11 .30)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (intch_tgt_op{3} .14 .9 .28) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .11 .30)]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .22 .33) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .33) (builtin_comp2_op{2} .2 [.34]) (assoc_op{3} .2 .15 .28) (builtin_comp2_op{2} [.16] .28) (builtin_assc_op{3} .14 .9 .28))) (intch_tgt_op{3} .14 .9 .28)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (builtin_comp2_func[(.4,1) (.8,1)]_op{3} [.13] [.32]))])).
+  [=^.^=] check cylcomp(4,2,4)
+  [=I.I=] valid term builtin_conecomp(3,2,3)_func[(.32,1) (.28,1) (.24,1) (.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (!1builtin_comp2 [.6] [.24]) .15)] .29) (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .5 .23 .15)] .29) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.23] .15) .29) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.23] .15) .29) (!1builtin_comp2 (builtin_comp2_op{2} [.5] .15) [.31]) (!1assoc (builtin_comp2_op{2} [.5] .15) .17 (builtin_comp2_op{2} .14 [.27])) (!1builtin_comp2 [.19] (builtin_comp2_op{2} .14 [.27])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.27])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.27]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .12 .27)]))) -> (!2builtin_comp2 (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .4 .22 .15)] .29) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .29) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .29) (!1builtin_comp2 (builtin_comp2_op{2} [.4] .15) [.30]) (!1assoc (builtin_comp2_op{2} [.4] .15) .17 (builtin_comp2_op{2} .14 [.26])) (!1builtin_comp2 [.18] (builtin_comp2_op{2} .14 [.26])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.26])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.26]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .11 .26)])) (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (!1builtin_comp2 [.13] [.28]))])).
+  [=^.^=] check cylcomp(4,3,4)
+  [=D.D=] substitution: (.0, .0) (.1, .6) (.2, (builtin_comp2 .2 .11)) (.3, (builtin_comp2 .3 .11)) (.4, (builtin_comp2 [.4] .11)) (.5, (builtin_comp2 .10 .7)) (.6, (builtin_comp2 .10 .8)) (.7, (builtin_comp2 .10 [.9])) (.8, .12) (.9, .13) (.10, .14) (.11, (builtin_comp2 .15 .11)) (.12, (builtin_comp2 [.16] .11)) (.13, (builtin_comp2 .10 .17)) (.14, (builtin_comp2 .10 [.18])) (.15, .19) (.16, .20)
+  
+  [=D.D=] substitution: (.0, .0) (.1, .8) (.2, (builtin_comp2 .2 .15)) (.3, (builtin_comp2 .3 .15)) (.4, (builtin_comp2 [.4] .15)) (.5, (builtin_comp2 [.5] .15)) (.6, (builtin_comp2 [[.6]] .15)) (.7, (builtin_comp2 .14 .9)) (.8, (builtin_comp2 .14 .10)) (.9, (builtin_comp2 .14 [.11])) (.10, (builtin_comp2 .14 [.12])) (.11, (builtin_comp2 .14 [[.13]])) (.12, .16) (.13, .17) (.14, .18) (.15, .19) (.16, .20) (.17, (builtin_comp2 [.21] .15)) (.18, (builtin_comp2 [[.22]] .15)) (.19, (builtin_comp2 .14 [.23])) (.20, (builtin_comp2 .14 [[.24]])) (.21, .25) (.22, .26)
+  
+  [=I.I=] valid term builtin_conecomp(4,3,4) of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2 [[(!2builtin_comp2 .6 .22)]] .15)] .17) .25) -> (!2builtin_comp2 .18 (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,2)]_op{1} (!2builtin_comp2 .13 .24) .14)])).
+  [=^.^=] check cylcomp(4,1,2)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.14,1) (.9,1) (.4,1)]_op{3}_func[(.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .6 .22) .25)] (!1builtin_comp3 (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 [(intch_src_func[(.4,1)]_op{3} .5 .22 .25)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1)]_op{3} .5 .22 .25) (builtin_comp2_func[(.8,1)][(.4,1)]_op{3} .5 .26) (assoc_func[(.4,1)]_op{3} .5 .15 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .19 .24) (builtin_assc_func[(.6,1)]_op{3} .14 .12 .24)))] (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) [(intch_tgt_func[(.6,1)]_op{3} .14 .12 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 [(intch_src_func[(.4,1)]_op{3} .4 .22 .25)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1)]_op{3} .4 .22 .25) (builtin_comp2_func[(.8,1)][(.4,1)]_op{3} .4 .26) (assoc_func[(.4,1)]_op{3} .4 .15 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .18 .24) (builtin_assc_func[(.6,1)]_op{3} .14 .11 .24)))] (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)])) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) [(intch_tgt_func[(.6,1)]_op{3} .14 .11 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .13 .24))])).
+  [=^.^=] check cylcomp(4,1,3)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.26,1) (.22,1) (.18,1) (.14,1) (.9,1) (.4,1)]_op{3}_func[(.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.6,1)]_red_func[(.6,1)]_op{3} .6 .24) .29)] (!1builtin_comp3 (intch_src_op{3} .3 .23 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .5 .24)] .29) (intch_src_op{3} .3 .23 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .5 .24)] .29) (intch_src_op{3} .3 .23 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp3 [(intch_src_func[(.4,1) (.8,1)]_op{3} .5 .24 .29)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .5 .24)] .29)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .29) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1) (.8,1)]_op{3} .5 .24 .29) (builtin_comp2_func[(.6,1)][(.2~,1) (.4~,1) (.5~,1) (.6~,1)]_op{3} .5 .32) (assoc_func[(.4,1) (.10,1)]_op{3} .5 .15 .28) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1) (.6~,1)]_op{3} .19 .28) (builtin_assc_func[(.6,1) (.10,1)]_op{3} .14 .12 .28)))] (intch_tgt_op{3} .14 .10 .27)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .12 .28)])) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) [(intch_tgt_func[(.6,1) (.10,1)]_op{3} .14 .12 .28)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (intch_tgt_op{3} .14 .9 .26) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .12 .28)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (intch_tgt_op{3} .14 .9 .26) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .12 .28)])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .24)] .29) (intch_src_op{3} .3 .23 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .24)] .29) (intch_src_op{3} .3 .23 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp3 [(intch_src_func[(.4,1) (.8,1)]_op{3} .4 .24 .29)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .24)] .29)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .23 .29) (builtin_comp2_op{2} .3 [.31]) (assoc_op{3} .3 .15 .27) (builtin_comp2_op{2} [.17] .27) (builtin_assc_op{3} .14 .10 .27))) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .29) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1) (.8,1)]_op{3} .4 .24 .29) (builtin_comp2_func[(.6,1)][(.2~,1) (.4~,1) (.5~,1) (.6~,1)]_op{3} .4 .32) (assoc_func[(.4,1) (.10,1)]_op{3} .4 .15 .28) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1) (.6~,1)]_op{3} .18 .28) (builtin_assc_func[(.6,1) (.10,1)]_op{3} .14 .11 .28)))] (intch_tgt_op{3} .14 .10 .27)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .11 .28)])) (intch_tgt_op{3} .14 .10 .27)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) [(intch_tgt_func[(.6,1) (.10,1)]_op{3} .14 .11 .28)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (intch_tgt_op{3} .14 .9 .26) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .11 .28)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (intch_tgt_op{3} .14 .9 .26) (builtin_comp2_op{2} .14 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .11 .28)]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .22 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .29) (builtin_comp2_op{2} .2 [.30]) (assoc_op{3} .2 .15 .26) (builtin_comp2_op{2} [.16] .26) (builtin_assc_op{3} .14 .9 .26))) (intch_tgt_op{3} .14 .9 .26)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (builtin_comp2_func[(.6,1)]_red_func[(.6,1)]_op{3} .13 .28))])).
+  [=^.^=] check cylcomp(2,1,4)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.20,1) (.16,1) (.12,1)]_op{3}_func[(.26,1) (.20,1) (.14,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .2 .14) .21)] (!1builtin_comp3 (intch_src_op{3} .2 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.13])] .21) (intch_src_op{3} .2 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.13])] .21) (intch_src_op{3} .2 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp3 [(intch_src_func[(.6,1)]_op{3} .2 .13 .21)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.13])] .21)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp3 (intch_src_op{3} .2 .10 .21) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.6,1)]_op{3} .2 .13 .21) (builtin_comp2_func[(.6,1)][(.4~,1) (.5~,1) (.6~,1)]_op{3} .2 .25) (assoc_func[(.8,1)]_op{3} .2 .7 .19) (builtin_comp2_func[(.4,1)][(.8,1)]_op{3} .8 .19) (builtin_assc_func[(.8,1)]_op{3} .6 .5 .19)))] (intch_tgt_op{3} .6 .5 .17)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.19])])) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp3 (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) [(intch_tgt_func[(.8,1)]_op{3} .6 .5 .19)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (intch_tgt_op{3} .6 .5 .16) (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.19])])))) (intch_src_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (intch_tgt_op{3} .6 .5 .16) (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.19])])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.12])] .21) (intch_src_op{3} .2 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.12])] .21) (intch_src_op{3} .2 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp3 [(intch_src_func[(.6,1)]_op{3} .2 .12 .21)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} .2 [.12])] .21)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .11 .21) (builtin_comp2_op{2} .2 [.23]) (assoc_op{3} .2 .7 .17) (builtin_comp2_op{2} [.8] .17) (builtin_assc_op{3} .6 .5 .17))) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp3 (intch_src_op{3} .2 .10 .21) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.6,1)]_op{3} .2 .12 .21) (builtin_comp2_func[(.6,1)][(.4~,1) (.5~,1) (.6~,1)]_op{3} .2 .24) (assoc_func[(.8,1)]_op{3} .2 .7 .18) (builtin_comp2_func[(.4,1)][(.8,1)]_op{3} .8 .18) (builtin_assc_func[(.8,1)]_op{3} .6 .5 .18)))] (intch_tgt_op{3} .6 .5 .17)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.18])])) (intch_tgt_op{3} .6 .5 .17)) (!1builtin_comp3 (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) [(intch_tgt_func[(.8,1)]_op{3} .6 .5 .18)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (intch_tgt_op{3} .6 .5 .16) (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.18])])))) (intch_src_op{3} (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (intch_tgt_op{3} .6 .5 .16) (builtin_comp2_op{2} .6 [(builtin_comp2_op{2} .5 [.18])]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .10 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .10 .21) (builtin_comp2_op{2} .2 [.22]) (assoc_op{3} .2 .7 .16) (builtin_comp2_op{2} [.8] .16) (builtin_assc_op{3} .6 .5 .16))) (intch_tgt_op{3} .6 .5 .16)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .6 (builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .5 .20))])).
+  [=^.^=] check cylcomp(3,1,4)
+  [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.26,1) (.22,1) (.18,1) (.14,1) (.9,1) (.4,1)]_op{3}_func[(.32,1) (.26,1) (.20,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.6,1)]_red_func[(.10,1)]_op{3} .4 .20) .27)] (!1builtin_comp3 (intch_src_op{3} .3 .17 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .19)] .27) (intch_src_op{3} .3 .17 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .19)] .27) (intch_src_op{3} .3 .17 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp3 [(intch_src_func[(.4,1) (.8,1)]_op{3} .4 .19 .27)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .19)] .27)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp3 (intch_src_op{3} .2 .16 .27) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1) (.8,1)]_op{3} .4 .19 .27) (builtin_comp2_func[(.6,1)][(.2~,1) (.4~,1) (.5~,1) (.6~,1)]_op{3} .4 .31) (assoc_func[(.4,1) (.10,1)]_op{3} .4 .11 .25) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1) (.6~,1)]_op{3} .14 .25) (builtin_assc_func[(.6,1) (.10,1)]_op{3} .10 .9 .25)))] (intch_tgt_op{3} .10 .8 .23)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .25)])) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp3 (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) [(intch_tgt_func[(.6,1) (.10,1)]_op{3} .10 .9 .25)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (intch_tgt_op{3} .10 .7 .22) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .25)])))) (intch_src_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (intch_tgt_op{3} .10 .7 .22) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .25)])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .18)] .27) (intch_src_op{3} .3 .17 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .18)] .27) (intch_src_op{3} .3 .17 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp3 [(intch_src_func[(.4,1) (.8,1)]_op{3} .4 .18 .27)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .18)] .27)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .27) (builtin_comp2_op{2} .3 [.29]) (assoc_op{3} .3 .11 .23) (builtin_comp2_op{2} [.13] .23) (builtin_assc_op{3} .10 .8 .23))) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp3 (intch_src_op{3} .2 .16 .27) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1) (.8,1)]_op{3} .4 .18 .27) (builtin_comp2_func[(.6,1)][(.2~,1) (.4~,1) (.5~,1) (.6~,1)]_op{3} .4 .30) (assoc_func[(.4,1) (.10,1)]_op{3} .4 .11 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1) (.6~,1)]_op{3} .14 .24) (builtin_assc_func[(.6,1) (.10,1)]_op{3} .10 .9 .24)))] (intch_tgt_op{3} .10 .8 .23)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .24)])) (intch_tgt_op{3} .10 .8 .23)) (!1builtin_comp3 (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) [(intch_tgt_func[(.6,1) (.10,1)]_op{3} .10 .9 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (intch_tgt_op{3} .10 .7 .22) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (intch_tgt_op{3} .10 .7 .22) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .24)]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .27) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .27) (builtin_comp2_op{2} .2 [.28]) (assoc_op{3} .2 .11 .22) (builtin_comp2_op{2} [.12] .22) (builtin_assc_op{3} .10 .7 .22))) (intch_tgt_op{3} .10 .7 .22)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .10 (builtin_comp2_func[(.6,1)]_red_func[(.10,1)]_op{3} .9 .26))])).
+  [=^.^=] check cylcomp(4,2,3)
+  [=I.I=] valid term builtin_conecomp(3,2,3)_func[(.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (!1builtin_comp2 [.6] .22) .15)] .25) (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .5 .22 .15)] .25) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.22] .15) .25) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.22] .15) .25) (!1builtin_comp2 (builtin_comp2_op{2} [.5] .15) [.26]) (!1assoc (builtin_comp2_op{2} [.5] .15) .17 (builtin_comp2_op{2} .14 [.24])) (!1builtin_comp2 [.19] (builtin_comp2_op{2} .14 [.24])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.24])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.24]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .12 .24)]))) -> (!2builtin_comp2 (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .4 .22 .15)] .25) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .25) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .25) (!1builtin_comp2 (builtin_comp2_op{2} [.4] .15) [.26]) (!1assoc (builtin_comp2_op{2} [.4] .15) .17 (builtin_comp2_op{2} .14 [.24])) (!1builtin_comp2 [.18] (builtin_comp2_op{2} .14 [.24])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.24])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.24]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .11 .24)])) (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (!1builtin_comp2 [.13] .24))])).
+  [=^.^=] check cylcomp(3,2,4)
+  [=I.I=] valid term builtin_conecomp(3,2,3)_func[(.26,1) (.22,1) (.18,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (!1builtin_comp2 .4 [.18]) .11)] .23) (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .4 .17 .11)] .23) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.4] .11) (builtin_comp2_op{2} [.17] .11) .23) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.4] .11) (builtin_comp2_op{2} [.17] .11) .23) (!1builtin_comp2 (builtin_comp2_op{2} [.4] .11) [.25]) (!1assoc (builtin_comp2_op{2} [.4] .11) .13 (builtin_comp2_op{2} .10 [.21])) (!1builtin_comp2 [.14] (builtin_comp2_op{2} .10 [.21])) (!1builtin_assc .12 (builtin_comp2_op{2} .10 [.9]) (builtin_comp2_op{2} .10 [.21])))) (!1intch_tgt .12 (builtin_comp2_op{2} .10 [.9]) (builtin_comp2_op{2} .10 [.21]))) (!1builtin_comp2 .12 [(builtin_comp_1_0_intch_op{1}^-1 .10 .9 .21)]))) -> (!2builtin_comp2 (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .4 .16 .11)] .23) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.4] .11) (builtin_comp2_op{2} [.16] .11) .23) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.4] .11) (builtin_comp2_op{2} [.16] .11) .23) (!1builtin_comp2 (builtin_comp2_op{2} [.4] .11) [.24]) (!1assoc (builtin_comp2_op{2} [.4] .11) .13 (builtin_comp2_op{2} .10 [.20])) (!1builtin_comp2 [.14] (builtin_comp2_op{2} .10 [.20])) (!1builtin_assc .12 (builtin_comp2_op{2} .10 [.9]) (builtin_comp2_op{2} .10 [.20])))) (!1intch_tgt .12 (builtin_comp2_op{2} .10 [.9]) (builtin_comp2_op{2} .10 [.20]))) (!1builtin_comp2 .12 [(builtin_comp_1_0_intch_op{1}^-1 .10 .9 .20)])) (!1builtin_comp2 .12 [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .10 (!1builtin_comp2 .9 [.22]))])).
+  [=^.^=] check cylstack(2)
+  [=I.I=] valid term builtin_cylstack of type (builtin_comp2_op{2} .2 (builtin_comp2_op{2} .7 .13)) -> (builtin_comp2_op{2} (builtin_comp2_op{2} .6 .12) .11).
+  [=^.^=] check cylstack(3)
+  [=I.I=] valid term builtin_cylstack_func[(.24,1) (.19,1) (.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [.4] (builtin_comp2_op{2} .11 .21)) (!1builtin_comp3 (intch_tgt_op{2} .3 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .11 .21) (builtin_comp2_op{2} [.13] .21) (builtin_assc_op{3} .10 .8 .21) (builtin_comp2_op{2} .10 [.23]) (assoc_op{3} .10 .20 .18))) (intch_src_op{2} .10 .20 .18))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_tgt_op{2} .2 .11 .21) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .11 .21) (builtin_comp2_op{2} [.12] .21) (builtin_assc_op{3} .10 .7 .21) (builtin_comp2_op{2} .10 [.22]) (assoc_op{3} .10 .20 .17))) (intch_src_op{2} .10 .20 .17)) (builtin_comp2_op{2} (builtin_comp2_op{2} .10 .20) [.19])).
+  [=^.^=] check cylstack(4)
+  [=I.I=] valid term builtin_cylstack_func[(.24,1) (.19,1) (.14,1) (.9,1) (.4,1)]_op{3}_func[(.34,1) (.27,1) (.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .6 (builtin_comp2_op{2} .15 .29))] (!1builtin_comp3 (intch_tgt_op{2} .3 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [.5] (builtin_comp2_op{2} .15 .29)) (intch_tgt_op{2} .3 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [.5] (builtin_comp2_op{2} .15 .29)) (intch_tgt_op{2} .3 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp3 [(intch_tgt_op{2}_func[(.4,1)]_op{3} .5 .15 .29)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_assc_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [.5] (builtin_comp2_op{2} .15 .29))) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp3 (intch_tgt_op{2} .2 .15 .29) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (assoc_func[(.4,1)]_op{3} .5 .15 .29) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .19 .29) (builtin_assc_func[(.6,1)]_op{3} .14 .12 .29) (builtin_comp2_func[(.6,1)][(.4~,1) (.5~,1) (.6~,1)]_op{3} .14 .33) (assoc_func[(.8,1)]_op{3} .14 .28 .26)))] (intch_src_op{2} .14 .28 .24)) (!1builtin_assc_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} (builtin_comp2_op{2} .14 .28) [.26])) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp3 (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) [(intch_src_op{2}_func[(.8,1)]_op{3} .14 .28 .26)]) (!1builtin_assc_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (intch_src_op{2} .14 .28 .23) (builtin_comp2_op{2} (builtin_comp2_op{2} .14 .28) [.26])))) (intch_src_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (intch_src_op{2} .14 .28 .23) (builtin_comp2_op{2} (builtin_comp2_op{2} .14 .28) [.26])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [.4] (builtin_comp2_op{2} .15 .29)) (intch_tgt_op{2} .3 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [.4] (builtin_comp2_op{2} .15 .29)) (intch_tgt_op{2} .3 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp3 [(intch_tgt_op{2}_func[(.4,1)]_op{3} .4 .15 .29)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_assc_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [.4] (builtin_comp2_op{2} .15 .29))) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .3 .15 .29) (builtin_comp2_op{2} [.17] .29) (builtin_assc_op{3} .14 .10 .29) (builtin_comp2_op{2} .14 [.31]) (assoc_op{3} .14 .28 .24))) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp3 (intch_tgt_op{2} .2 .15 .29) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (assoc_func[(.4,1)]_op{3} .4 .15 .29) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .18 .29) (builtin_assc_func[(.6,1)]_op{3} .14 .11 .29) (builtin_comp2_func[(.6,1)][(.4~,1) (.5~,1) (.6~,1)]_op{3} .14 .32) (assoc_func[(.8,1)]_op{3} .14 .28 .25)))] (intch_src_op{2} .14 .28 .24)) (!1builtin_assc_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} (builtin_comp2_op{2} .14 .28) [.25])) (intch_src_op{2} .14 .28 .24)) (!1builtin_comp3 (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) [(intch_src_op{2}_func[(.8,1)]_op{3} .14 .28 .25)]) (!1builtin_assc_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (intch_src_op{2} .14 .28 .23) (builtin_comp2_op{2} (builtin_comp2_op{2} .14 .28) [.25])))) (intch_src_op{3} (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (intch_src_op{2} .14 .28 .23) (builtin_comp2_op{2} (builtin_comp2_op{2} .14 .28) [.25]))) (!1builtin_comp2 (!1builtin_comp3 (intch_tgt_op{2} .2 .15 .29) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (assoc_op{3} .2 .15 .29) (builtin_comp2_op{2} [.16] .29) (builtin_assc_op{3} .14 .9 .29) (builtin_comp2_op{2} .14 [.30]) (assoc_op{3} .14 .28 .23))) (intch_src_op{2} .14 .28 .23)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} (builtin_comp2_op{2} .14 .28) .27)])).
+
+  $ catt --no-builtins features/eh.catt
+  [=^.^=] check eh^2_(0,1)
+  [=I.I=] valid term eh^2_(0,1) of type (builtin_comp2 [.1] [.2]) -> (!1builtin_comp3 (UBPad.p(1) .0) (!1builtin_comp2 .1 .2) (UBPad.p(1) .0)).
+  [=^.^=] check eh^3_(0,1)
+  [=I.I=] valid term eh^3_(0,1) of type (builtin_comp2 [[.1]] [[.2]]) -> (!2builtin_comp3 (UBPad.p(2) .0) (UBPad.Padding(2) [(!1builtin_comp2 [.1] [.2])]) (UBPad.p(2) .0)).
+  [=^.^=] check eh^4_(2,1)
+  [=I.I=] valid term eh^4_(2,1) of type (!2builtin_comp2 [.1] [.2]) -> (!3builtin_comp3 (UBPad.p(3) .0) (UBPad.Padding(3) [(!1builtin_comp2 [[.1]] [[.2]])]) (UBPad.p(3) .0)).
+  [=^.^=] check eh^3_(1,2)
+  [=I.I=] valid term eh^3_(1,2) of type (!1builtin_comp2 [.1] [.2]) -> (!2builtin_comp3 (UBPad.p(2) .0) (!2builtin_comp2 .1 .2) (UBPad.p(2) .0)).
+  [=^.^=] check eh^4_(3,2)
+  [=I.I=] valid term eh^4_(3,2) of type (!3builtin_comp2 .1 .2) -> (!3builtin_comp3 (UBPad.p(3) .0) (!2builtin_comp2 [.1] [.2]) (UBPad.p(3) .0)).
+  [=^.^=] check eh^3_(1,2)
+  [=I.I=] valid term eh^3_(1,2) of type (!1builtin_comp2 [.1] [.2]) -> (!2builtin_comp3 (UBPad.p(2) .0) (!2builtin_comp2 .1 .2) (UBPad.p(2) .0)).
+  [=^.^=] check eh^4_(2,3)
+  [=I.I=] valid term eh^4_(2,3) of type (!2builtin_comp2 [.1] [.2]) -> (!3builtin_comp3 (UBPad.p(3) .0) (!3builtin_comp2 .1 .2) (UBPad.p(3) .0)).
+  [=^.^=] check eh^3_(0,2)
+  [=I.I=] valid term eh^3_(0,2) of type (builtin_comp2 [[.1]] [[.2]]) -> (!2builtin_comp3 (UBPad.p(2) .0) (!1builtin_comp3 (UBPad.p(1) .0) [(!2builtin_comp2 .1 .2)] (UBPad.p(1) .0)) (UBPad.p(2) .0)).
+  [=^.^=] check eh^2_(1,0)
+  [=I.I=] valid term eh^2_(1,0) of type (!1builtin_comp2 .1 .2) -> (!1builtin_comp3 (UBPad.p(1) .0) (builtin_comp2 [.1] [.2]) (UBPad.p(1) .0)).
+  [=^.^=] check eh^3_(2,0)
+  [=I.I=] valid term eh^3_(2,0) of type (!2builtin_comp2 .1 .2) -> (!2builtin_comp3 (UBPad.p(2) .0) (!1builtin_comp3 (UBPad.p(1) .0) [(builtin_comp2 [[.1]] [[.2]])] (UBPad.p(1) .0)) (UBPad.p(2) .0)).
+  [=^.^=] check EH^2_(0,1)
+  [=I.I=] valid term (!2builtin_comp2 (eh^2_(0,1) .1 .2) (I(eh^2_(0,1)_op{2}) .2 .1)) of type (builtin_comp2 [.1] [.2]) -> (builtin_comp2_func[(.4,1) (.8,1)]_op{2} .2 .1).
+  [=^.^=] check EH^3_(0,1)
+  [=I.I=] valid term (!3builtin_comp2 (eh^3_(0,1) .1 .2) (I(eh^3_(0,1)_op{2}) .2 .1)) of type (builtin_comp2 [[.1]] [[.2]]) -> (builtin_comp2_func[(.6,2) (.12,2)]_op{2} .2 .1).
+  [=^.^=] check EH^3_(1,2)
+  [=I.I=] valid term (!3builtin_comp2 (eh^3_(1,2) .1 .2) (I(eh^3_(1,2)_op{3}) .2 .1)) of type (!1builtin_comp2 [.1] [.2]) -> (!1builtin_comp2_func[(.6,1) (.10,1)]_op{3} .2 .1).
+  [=^.^=] check EH^3_(1,2)
+  [=I.I=] valid term (!3builtin_comp2 (eh^3_(1,2) .1 .2) (I(eh^3_(1,2)_op{3}) .2 .1)) of type (!1builtin_comp2 [.1] [.2]) -> (!1builtin_comp2_func[(.6,1) (.10,1)]_op{3} .2 .1).
+  [=^.^=] check EH^3_(2,0)
+  [=I.I=] valid term (!3builtin_comp2 (eh^3_(2,0) .1 .2) (I(eh^3_(2,0)_op{1}) .2 .1)) of type (!2builtin_comp2 .1 .2) -> (!2builtin_comp2 .2 .1).

From b4f85462489f93f68166de9bd9595eeadabf3fb7 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Thu, 11 Sep 2025 09:52:11 +0200
Subject: [PATCH 06/30] [misc] review

---
 lib/kernel.ml    | 13 ++++++++++---
 lib/unchecked.ml | 18 +++++++++---------
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/lib/kernel.ml b/lib/kernel.ml
index 9f4a0639..5ce16da0 100644
--- a/lib/kernel.ml
+++ b/lib/kernel.ml
@@ -457,9 +457,6 @@ end = struct
   let ty t = Ty.forget t.ty
   let tbl : (Ctx.t * Types.tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
 
-  (* TODO: this is incorrect: an applied term can be a variable *)
-  let to_var tm = match tm.e with Var v -> v | Coh _ | App _ -> raise IsCoh
-
   let free_vars tm =
     let fvty = Ty.free_vars tm.ty in
     match tm.e with
@@ -519,6 +516,16 @@ end = struct
         tm.developped <- Some dev;
         dev
 
+  let to_var tm =
+    match tm.e with
+    | Var v -> v
+    | Coh _ -> raise IsCoh
+    | App _ -> (
+        match develop tm with
+        | Var v -> v
+        | Coh _ -> raise IsCoh
+        | App _ | Meta_tm _ -> assert false)
+
   let apply_sub t sub =
     Ctx.check_equal (Sub.tgt sub) (Ty.ctx t.ty);
     let c = Sub.src sub in
diff --git a/lib/unchecked.ml b/lib/unchecked.ml
index b55b8d97..0abea270 100644
--- a/lib/unchecked.ml
+++ b/lib/unchecked.ml
@@ -582,6 +582,15 @@ struct
             s
       | Meta_tm _ -> Error.fatal "meta-variables should be resolved"
 
+    let rec ty_contains_var a x =
+      match a with
+      | Obj -> false
+      | Arr (a, t, u) ->
+          tm_contains_var t x || tm_contains_var u x || ty_contains_var a x
+      | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
+
+    let tm_contains_vars t l = List.exists (tm_contains_var t) l
+
     let rec check_equal_ps ps1 ps2 =
       match (ps1, ps2) with
       | Br [], Br [] -> ()
@@ -664,15 +673,6 @@ struct
     let check_equal_ctx ctx1 ctx2 =
       if ctx1 == ctx2 then () else check_equal_ctx ctx1 ctx2
 
-    let rec ty_contains_var a x =
-      match a with
-      | Obj -> false
-      | Arr (a, t, u) ->
-          tm_contains_var t x || tm_contains_var u x || ty_contains_var a x
-      | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
-
-    let tm_contains_vars t l = List.exists (tm_contains_var t) l
-
     let rec list_to_sub s ctx =
       match (s, ctx) with
       | t :: s, (x, (_, expl)) :: ctx -> (x, (t, expl)) :: list_to_sub s ctx

From 3387a6bb927ae1f7fb62346043aa13f1bfc4b9d7 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 30 Sep 2025 17:38:43 +0200
Subject: [PATCH 07/30] [refactor] separate file for printing module

---
 coq_plugin/src/export.ml |   2 +-
 lib/command.ml           |  11 +--
 lib/cubical_composite.ml |   2 +-
 lib/cylinders.ml         |   1 -
 lib/elaborate.ml         |  48 +++++-----
 lib/environment.ml       |   8 +-
 lib/inverse.ml           |   6 +-
 lib/kernel.ml            |  53 +++++++----
 lib/kernel.mli           |  23 +++--
 lib/opposite.ml          |   6 +-
 lib/printing.ml          | 198 +++++++++++++++++++++++++++++++++++++++
 lib/ps_reduction.ml      |   2 +-
 lib/unchecked.ml         | 193 +++-----------------------------------
 lib/unchecked.mli        |  10 --
 14 files changed, 296 insertions(+), 267 deletions(-)
 create mode 100644 lib/printing.ml

diff --git a/coq_plugin/src/export.ml b/coq_plugin/src/export.ml
index d1ed6efc..7a849a4a 100644
--- a/coq_plugin/src/export.ml
+++ b/coq_plugin/src/export.ml
@@ -232,7 +232,7 @@ end = struct
     | Some res -> res
     | None ->
         let ps, ty, name = Coh.forget coh in
-        let name = clean_name (Unchecked.full_name name) in
+        let name = clean_name (Printing.full_name name) in
         let ctx = Unchecked.ps_to_ctx ps in
         let l_ind = induction_vars ps in
         let l_ind = induction_data l_ind ctx in
diff --git a/lib/command.ml b/lib/command.ml
index 8863d1b3..5531d0ff 100644
--- a/lib/command.ml
+++ b/lib/command.ml
@@ -103,16 +103,15 @@ let exec_cmd cmd =
       let e, ty = check l e t in
       Io.info
         (lazy
-          (Printf.sprintf "valid term %s of type %s" (Unchecked.tm_to_string e)
-             (Unchecked.ty_to_string ty)))
+          (Printf.sprintf "valid term %s of type %s" (Printing.tm_to_string e)
+             (Printing.ty_to_string ty)))
   | Decl (v, l, e, t) ->
       Io.command "let %s = %s" (Var.to_string v) (Raw.string_of_tm e);
       let tm, ty = exec_decl v l e t in
       Io.info
         (lazy
           (Printf.sprintf "successfully defined term %s of type %s"
-             (Unchecked.tm_to_string tm)
-             (Unchecked.ty_to_string ty)))
+             (Printing.tm_to_string tm) (Printing.ty_to_string ty)))
   | Set (o, v) -> (
       try exec_set o v with
       | UnknownOption o -> Error.unknown_option o
@@ -125,7 +124,7 @@ let exec_cmd cmd =
         (lazy
           (Printf.sprintf "valid term %s of type %s"
              (Environment.value_to_string e)
-             (Unchecked.ty_to_string ty)))
+             (Printing.ty_to_string ty)))
   | Decl_builtin (v, b) ->
       Io.command "let %s = %s" (Var.to_string v) (Raw.string_of_builtin b);
       let e, ty = exec_decl_builtin v b in
@@ -133,7 +132,7 @@ let exec_cmd cmd =
         (lazy
           (Printf.sprintf "successfully defined term %s of type %s"
              (Environment.value_to_string e)
-             (Unchecked.ty_to_string ty)))
+             (Printing.ty_to_string ty)))
 
 type next = Abort | KeepGoing | Interactive
 
diff --git a/lib/cubical_composite.ml b/lib/cubical_composite.ml
index 73e94890..5801e05f 100644
--- a/lib/cubical_composite.ml
+++ b/lib/cubical_composite.ml
@@ -380,7 +380,7 @@ let bridge_ps ps_inter l_inter d =
 let bridge_coh coh ps_bridge =
   let _, _, name = Coh.forget coh in
   let src, tgt, _ = Coh.noninv_srctgt coh in
-  let name_red = (Unchecked.full_name name ^ "_red", 0, []) in
+  let name_red = (Printing.full_name name ^ "_red", 0, []) in
   let coh_bridge = Coh.check_noninv ps_bridge src tgt name_red in
   coh_bridge
 
diff --git a/lib/cylinders.ml b/lib/cylinders.ml
index d7428f28..65a0883a 100644
--- a/lib/cylinders.ml
+++ b/lib/cylinders.ml
@@ -319,7 +319,6 @@ module Codim1 = struct
               (Induct.ctx n)
               (Suspension.sub (Some 1) (Cylinder.bdry_left (n - 1) (n - 2)))
           in
-          Io.debug "substitution:%s" (Unchecked.sub_to_string_debug sub);
           check_term (Ctx.check ctx_comp) ~name:(name, 0, []) (App (comp, sub))
         in
         let intch_lower, intch_upper = intch n in
diff --git a/lib/elaborate.ml b/lib/elaborate.ml
index 5dcb0f5e..c464be0f 100644
--- a/lib/elaborate.ml
+++ b/lib/elaborate.ml
@@ -16,14 +16,14 @@ module Constraints = struct
     let print_ty =
       Queue.fold c.ty ~init:"" ~f:(fun s (ty1, ty2) ->
           Printf.sprintf "%s (%s = %s)" s
-            (Unchecked.ty_to_string ty1)
-            (Unchecked.ty_to_string ty2))
+            (Printing.ty_to_string ty1)
+            (Printing.ty_to_string ty2))
     in
     let print_tm =
       Queue.fold c.tm ~init:"" ~f:(fun s (tm1, tm2) ->
           Printf.sprintf "%s (%s = %s)" s
-            (Unchecked.tm_to_string tm1)
-            (Unchecked.tm_to_string tm2))
+            (Printing.tm_to_string tm1)
+            (Printing.tm_to_string tm2))
     in
     Printf.sprintf "[%s] [%s]" print_ty print_tm
 
@@ -37,7 +37,7 @@ module Constraints = struct
     | Meta_ty _, _ | _, Meta_ty _ -> Queue.enqueue cst.ty (ty1, ty2)
     | Arr (_, _, _), Obj | Obj, Arr (_, _, _) ->
         raise
-          (NotUnifiable (Unchecked.ty_to_string ty1, Unchecked.ty_to_string ty2))
+          (NotUnifiable (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
 
   and unify_tm cst tm1 tm2 =
     match (tm1, tm2) with
@@ -56,7 +56,7 @@ module Constraints = struct
         unify_tm cst (Unchecked.tm_apply_sub (Tm.develop t) s) tm2
     | Var _, Coh _ | Coh _, Var _ | Var _, Var _ ->
         raise
-          (NotUnifiable (Unchecked.tm_to_string tm1, Unchecked.tm_to_string tm2))
+          (NotUnifiable (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
 
   and unify_sub cst s1 s2 =
     match (s1, s2) with
@@ -66,7 +66,7 @@ module Constraints = struct
         unify_sub cst s1 s2
     | [], _ :: _ | _ :: _, [] ->
         raise
-          (NotUnifiable (Unchecked.sub_to_string s1, Unchecked.sub_to_string s2))
+          (NotUnifiable (Printing.sub_to_string s1, Printing.sub_to_string s2))
 
   and unify_sub_ps cst s1 s2 =
     match (s1, s2) with
@@ -77,7 +77,7 @@ module Constraints = struct
     | [], _ :: _ | _ :: _, [] ->
         raise
           (NotUnifiable
-             (Unchecked.sub_ps_to_string s1, Unchecked.sub_ps_to_string s2))
+             (Printing.sub_ps_to_string s1, Printing.sub_ps_to_string s2))
 
   type mgu = { uty : (int * ty) list; utm : (int * tm) list }
 
@@ -190,9 +190,9 @@ module Constraints_typing = struct
     Io.info ~v:5
       (lazy
         (Printf.sprintf "constraint typing term %s in ctx %s, meta_ctx %s"
-           (Unchecked.tm_to_string t)
-           (Unchecked.ctx_to_string ctx)
-           (Unchecked.meta_ctx_to_string meta_ctx)));
+           (Printing.tm_to_string t)
+           (Printing.ctx_to_string ctx)
+           (Printing.meta_ctx_to_string meta_ctx)));
     match t with
     | Var v -> (
         try (t, fst (List.assoc v ctx))
@@ -219,10 +219,10 @@ module Constraints_typing = struct
       (lazy
         (Printf.sprintf
            "constraint typing substitution %s in ctx %s, target %s, meta_ctx %s"
-           (Unchecked.sub_to_string_debug s)
-           (Unchecked.ctx_to_string src)
-           (Unchecked.ctx_to_string tgt)
-           (Unchecked.meta_ctx_to_string meta_ctx)));
+           (Printing.sub_to_string_debug s)
+           (Printing.ctx_to_string src)
+           (Printing.ctx_to_string tgt)
+           (Printing.meta_ctx_to_string meta_ctx)));
     match (s, tgt) with
     | [], [] -> []
     | (x, (u, e)) :: s, (_, (t, _)) :: c ->
@@ -236,9 +236,9 @@ module Constraints_typing = struct
     Io.info ~v:5
       (lazy
         (Printf.sprintf "constraint typing type %s in ctx %s, meta_ctx %s"
-           (Unchecked.ty_to_string t)
-           (Unchecked.ctx_to_string ctx)
-           (Unchecked.meta_ctx_to_string meta_ctx)));
+           (Printing.ty_to_string t)
+           (Printing.ctx_to_string ctx)
+           (Printing.meta_ctx_to_string meta_ctx)));
     match t with
     | Obj -> Obj
     | Arr (a, u, v) ->
@@ -293,7 +293,7 @@ let solve_cst ~elab_fn ~print_fn ~kind x =
 let ctx c =
   let c, meta_ctx = Translate_raw.ctx c in
   let elab_fn c = fst (Constraints_typing.ctx c meta_ctx) in
-  solve_cst ~elab_fn ~print_fn:Unchecked.ctx_to_string ~kind:"context" c
+  solve_cst ~elab_fn ~print_fn:Printing.ctx_to_string ~kind:"context" c
 
 let elab_ty ctx meta_ctx ty =
   let cst = Constraints.create () in
@@ -320,7 +320,7 @@ let ty c ty =
     let c = ctx c in
     let ty, meta_ctx = Translate_raw.ty ty in
     let elab_fn ty = elab_ty c meta_ctx ty in
-    let print_fn = Unchecked.ty_to_string in
+    let print_fn = Printing.ty_to_string in
     (c, solve_cst ~elab_fn ~print_fn ~kind:"type" ty)
   with Error.UnknownId s -> raise (Error.unknown_id s)
 
@@ -331,7 +331,7 @@ let tm c tm =
     let c = ctx c in
     let tm, meta_ctx = Translate_raw.tm tm in
     let elab_fn tm = elab_tm c meta_ctx tm in
-    let print_fn = Unchecked.tm_to_string in
+    let print_fn = Printing.tm_to_string in
     (c, solve_cst ~elab_fn ~print_fn ~kind:"term" tm)
   with Error.UnknownId s -> raise (Error.unknown_id s)
 
@@ -343,13 +343,13 @@ let ty_in_ps ps t =
     let t, meta_ctx = Translate_raw.ty t in
     let t =
       let elab_fn ty = elab_ty ps meta_ctx ty in
-      solve_cst ~elab_fn ~print_fn:Unchecked.ty_to_string ~kind:"type" t
+      solve_cst ~elab_fn ~print_fn:Printing.ty_to_string ~kind:"type" t
     in
     try
       let _, names, _ = Unchecked.db_levels ps in
       ( Kernel.PS.(forget (mk (Kernel.Ctx.check ps))),
         Unchecked.rename_ty t names )
     with
-    | Kernel.PS.Invalid -> raise (Error.invalid_ps (Unchecked.ctx_to_string ps))
-    | DoubledVar x -> raise (Error.doubled_var (Unchecked.ctx_to_string ps) x)
+    | Kernel.PS.Invalid -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
+    | DoubledVar x -> raise (Error.doubled_var (Printing.ctx_to_string ps) x)
   with Error.UnknownId s -> raise (Error.unknown_id s)
diff --git a/lib/environment.ml b/lib/environment.ml
index c9501f78..2f94ba27 100644
--- a/lib/environment.ml
+++ b/lib/environment.ml
@@ -49,11 +49,10 @@ let add_let v c ?ty t =
     Io.info ~v:4
       (lazy
         (Printf.sprintf "term %s of type %s added to environment"
-           (Unchecked.tm_to_string t)
-           (Unchecked.ty_to_string ty)));
+           (Printing.tm_to_string t) (Printing.ty_to_string ty)));
     Hashtbl.add env v { value = Tm tm; dim_input; dim_output };
     (t, ty)
-  with DoubledVar x -> Error.doubled_var (Unchecked.ctx_to_string c) x
+  with DoubledVar x -> Error.doubled_var (Printing.ctx_to_string c) x
 
 let add_coh v ps ty =
   let coh = check_coh ps ty (Var.to_string v, 0, []) in
@@ -76,8 +75,7 @@ let add_value v value =
   Io.info ~v:4
     (lazy
       (Printf.sprintf "term %s of type %s added to environment"
-         (value_to_string value)
-         (Unchecked.ty_to_string ty)));
+         (value_to_string value) (Printing.ty_to_string ty)));
   Hashtbl.add env v { value; dim_input; dim_output };
   (value, ty)
 
diff --git a/lib/inverse.ml b/lib/inverse.ml
index ed5f223d..057778cf 100644
--- a/lib/inverse.ml
+++ b/lib/inverse.ml
@@ -49,7 +49,7 @@ let compute_inverse t =
   try compute_inverse t
   with NotInvertible s ->
     Error.inversion
-      ("term: " ^ Unchecked.tm_to_string t)
+      ("term: " ^ Printing.tm_to_string t)
       (Printf.sprintf "term %s is not invertible" s)
 
 let group_vertically ps t src_t tgt_t =
@@ -238,11 +238,11 @@ let compute_witness t =
   try
     let r = compute_witness t in
     Io.info ~v:3
-      (lazy (Printf.sprintf "inverse term: %s" (Unchecked.tm_to_string r)));
+      (lazy (Printf.sprintf "inverse term: %s" (Printing.tm_to_string r)));
     r
   with NotInvertible s ->
     Error.inversion
-      ("term: " ^ Unchecked.tm_to_string t)
+      ("term: " ^ Printing.tm_to_string t)
       (Printf.sprintf "term %s is not invertible" s)
 
 let inverse t =
diff --git a/lib/kernel.ml b/lib/kernel.ml
index 5ce16da0..46a9492b 100644
--- a/lib/kernel.ml
+++ b/lib/kernel.ml
@@ -2,6 +2,7 @@ open Std
 open Common
 open Unchecked_types
 open Unchecked
+open Printing
 
 exception IsObj
 exception IsCoh
@@ -32,6 +33,8 @@ end = struct
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
+  open Printing (Coh) (Tm)
+  module Printing = Make (Coh) (Tm)
 
   let tbl : (Ctx.t * PS.t * Types.sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
   let free_vars s = List.concat (List.map Tm.free_vars s.list)
@@ -42,11 +45,9 @@ end = struct
         (Printf.sprintf
            "building kernel substitution : source = %s; substitution = %s; \
             target = %s"
-           (Ctx.to_string src)
-           (Unchecked.sub_to_string s)
-           (Ctx.to_string tgt)));
+           (Ctx.to_string src) (Printing.sub_to_string s) (Ctx.to_string tgt)));
     let sub_exn =
-      InvalidSubTarget (Unchecked.sub_to_string_debug s, Ctx.to_string tgt)
+      InvalidSubTarget (Printing.sub_to_string_debug s, Ctx.to_string tgt)
     in
     let rec aux src s tgt =
       let expr s tgt =
@@ -102,6 +103,8 @@ end = struct
   open Unchecked_types (Coh) (Tm)
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
+  open Printing (Coh) (Tm)
+  module Printing = Make (Coh) (Tm)
 
   let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
@@ -119,7 +122,7 @@ end = struct
   let domain ctx = List.map fst ctx.c
   let value ctx = ctx.c
   let forget c = c.unchecked
-  let to_string ctx = Unchecked.ctx_to_string (forget ctx)
+  let to_string ctx = Printing.ctx_to_string (forget ctx)
 
   let check_equal ctx1 ctx2 =
     if ctx1 == ctx2 then ()
@@ -171,6 +174,8 @@ end = struct
 
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
+  open Printing (Coh) (Tm)
+  module Printing = Make (Coh) (Tm)
 
   (** A pasting scheme. *)
   type ps_derivation =
@@ -287,7 +292,7 @@ end = struct
         ps
 
   let forget ps = ps.tree
-  let to_string ps = Unchecked.ps_to_string (forget ps)
+  let to_string ps = Printing.ps_to_string (forget ps)
 
   (** Create a context from a pasting scheme. *)
   let to_ctx ps = ps.ctx
@@ -327,6 +332,8 @@ end = struct
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
+  open Printing (Coh) (Tm)
+  module Printing = Make (Coh) (Tm)
 
   (** A type exepression. *)
   type expr = Obj | Arr of t * Tm.t * Tm.t
@@ -347,7 +354,7 @@ end = struct
     Io.info ~v:5
       (lazy
         (Printf.sprintf "building kernel type %s in context %s"
-           (Unchecked.ty_to_string t) (Ctx.to_string c)));
+           (Printing.ty_to_string t) (Ctx.to_string c)));
     match Hashtbl.find_opt tbl (c, t) with
     | Some ty -> ty
     | None ->
@@ -374,7 +381,7 @@ end = struct
 
   let is_full t = List.included (Ctx.domain t.c) (free_vars t)
   let forget t = t.unchecked
-  let to_string ty = Unchecked.ty_to_string (forget ty)
+  let to_string ty = Printing.ty_to_string (forget ty)
 
   (** Test for equality. *)
   let check_equal ty1 ty2 =
@@ -442,6 +449,8 @@ end = struct
   module Unchecked = Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
   module Display_maps = Unchecked.Display_maps
+  open Printing (Coh) (Tm)
+  module Printing = Make (Coh) (Tm)
 
   type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
 
@@ -471,7 +480,7 @@ end = struct
     Io.info ~v:5
       (lazy
         (Printf.sprintf "building kernel term %s in context %s"
-           (Unchecked.tm_to_string t) (Ctx.to_string c)));
+           (Printing.tm_to_string t) (Ctx.to_string c)));
     let tm =
       match Hashtbl.find_opt tbl (c, t) with
       | Some tm -> tm
@@ -555,15 +564,15 @@ end = struct
 
   let bdry t = (Ty.source (typ t), Ty.target (typ t))
   let ctx t = Ctx.forget (Ty.ctx (typ t))
-  let name t = Option.map Unchecked.pp_data_to_string t.name
-  let full_name t = Option.map Unchecked.full_name t.name
+  let name t = Option.map Printing.pp_data_to_string t.name
+  let full_name t = Option.map Printing.full_name t.name
   let func_data t = Option.map (fun (_, _, f) -> f) t.name
   let pp_data t = t.name
 
   let to_string t =
     match full_name t with
     | Some name -> name
-    | None -> Unchecked.tm_to_string (forget t)
+    | None -> Printing.tm_to_string (forget t)
 
   let of_coh coh =
     let ps, _, pp_data = Coh.forget coh in
@@ -643,6 +652,8 @@ end = struct
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
   module Display_maps = Unchecked.Display_maps
+  open Printing (Coh) (Tm)
+  module Printing = Make (Coh) (Tm)
 
   let ps = function Inv (data, _) -> data.ps | NonInv (data, _) -> data.ps
 
@@ -677,8 +688,8 @@ end = struct
     Io.info ~v:5
       (lazy
         (Printf.sprintf "checking coherence (%s,%s)"
-           (Unchecked.ps_to_string ps_unchkd)
-           (Unchecked.ty_to_string t_unchkd)));
+           (Printing.ps_to_string ps_unchkd)
+           (Printing.ty_to_string t_unchkd)));
     match Hashtbl.find_opt tbl (ps_unchkd, t_unchkd) with
     | Some coh -> coh
     | None -> (
@@ -693,8 +704,8 @@ end = struct
         | NotAlgebraic ->
             Error.not_valid_coherence name
               (Printf.sprintf "type %s not algebraic in pasting scheme %s"
-                 (Unchecked.ty_to_string t_unchkd)
-                 Unchecked.(ctx_to_string (ps_to_ctx ps_unchkd)))
+                 (Printing.ty_to_string t_unchkd)
+                 (Printing.ctx_to_string (Unchecked.ps_to_ctx ps_unchkd)))
         | DoubledVar s ->
             Error.not_valid_coherence name
               (Printf.sprintf "variable %s appears twice in the context" s))
@@ -745,7 +756,7 @@ end = struct
 
   let to_string c =
     let ps, ty, pp_data = data c in
-    if not !Settings.unroll_coherences then Unchecked.pp_data_to_string pp_data
+    if not !Settings.unroll_coherences then Printing.pp_data_to_string pp_data
     else Printf.sprintf "Coh(%s,%s)" (PS.to_string ps) (Ty.to_string ty)
 
   let noninv_srctgt c =
@@ -798,6 +809,8 @@ end
 module U = Unchecked (Coh) (Tm)
 module Unchecked = U.Make (Coh) (Tm)
 module Display_maps = Unchecked.Display_maps
+module P = Printing (Coh) (Tm)
+module Printing = P.Make (Coh) (Tm)
 
 let check check_fn name =
   let v = 2 in
@@ -821,12 +834,12 @@ let check check_fn name =
         (if !Settings.verbosity >= v then fname else Lazy.force name)
 
 let check_type ctx a =
-  let ty = lazy ("type: " ^ Unchecked.ty_to_string a) in
+  let ty = lazy ("type: " ^ Printing.ty_to_string a) in
   check (fun () -> Ty.check ctx a) ty
 
 let check_term ctx ?ty ?name t =
   let ty = Option.map (check_type ctx) ty in
-  let tm = lazy ("term: " ^ Unchecked.tm_to_string t) in
+  let tm = lazy ("term: " ^ Printing.tm_to_string t) in
   check (fun () -> Tm.check ctx ?ty ?name t) tm
 
 let check_constr ?name ctx constr =
@@ -836,7 +849,7 @@ let check_constr ?name ctx constr =
   check_term ctx ?ty ?name t
 
 let check_coh ps ty pp_data =
-  let c = lazy ("coherence: " ^ Unchecked.pp_data_to_string pp_data) in
+  let c = lazy ("coherence: " ^ Printing.pp_data_to_string pp_data) in
   check (fun () -> Coh.check ps ty pp_data) c
 
 let check_sub src s tgt = ignore @@ Sub.check (Ctx.check src) s (Ctx.check tgt)
diff --git a/lib/kernel.mli b/lib/kernel.mli
index e7d907a9..48ed2d3a 100644
--- a/lib/kernel.mli
+++ b/lib/kernel.mli
@@ -100,16 +100,6 @@ end
 module Unchecked : sig
   type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
 
-  val ps_to_string : ps -> string
-  val ty_to_string : ty -> string
-  val tm_to_string : tm -> string
-  val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
-  val ctx_to_string : ctx -> string
-  val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
-  val sub_to_string_debug : sub -> string
-  val meta_ctx_to_string : meta_ctx -> string
-  val pp_data_to_string : ?print_func:bool -> pp_data -> string
-  val full_name : pp_data -> string
   val check_equal_ctx : ctx -> ctx -> unit
   val check_equal_ps : ps -> ps -> unit
   val check_equal_ty : ty -> ty -> unit
@@ -174,6 +164,19 @@ module Unchecked : sig
   val develop_ty : ty -> ty
 end
 
+module Printing : sig
+  val ps_to_string : ps -> string
+  val ty_to_string : ty -> string
+  val tm_to_string : tm -> string
+  val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
+  val ctx_to_string : ctx -> string
+  val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
+  val sub_to_string_debug : sub -> string
+  val meta_ctx_to_string : meta_ctx -> string
+  val pp_data_to_string : ?print_func:bool -> pp_data -> string
+  val full_name : pp_data -> string
+end
+
 module Display_maps : sig
   val var_apply_sub : Var.t -> sub -> Var.t
   val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
diff --git a/lib/opposite.ml b/lib/opposite.ml
index b8313637..b6fc534d 100644
--- a/lib/opposite.ml
+++ b/lib/opposite.ml
@@ -31,7 +31,7 @@ let equiv_op_ps ps op_data =
   level 0 ps
 
 let op_pp_data pp_data op_data =
-  let name = Unchecked.full_name pp_data in
+  let name = Printing.full_name pp_data in
   let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
   (name, 0, [])
 
@@ -96,9 +96,9 @@ let coh c op_data =
   coh c op_data equiv
 
 let tm t op_data =
-  Io.info ~v:3 (lazy ("computing opposite of term " ^ Unchecked.tm_to_string t));
+  Io.info ~v:3 (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
   let t = tm t op_data in
-  Io.info ~v:4 (lazy ("opposite computed: " ^ Unchecked.tm_to_string t));
+  Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
   t
 
 let checked_tm t op_data =
diff --git a/lib/printing.ml b/lib/printing.ml
new file mode 100644
index 00000000..f46903fb
--- /dev/null
+++ b/lib/printing.ml
@@ -0,0 +1,198 @@
+open Common
+open Unchecked_types
+
+module Printing (CohT : sig
+  type t
+end) (TmT : sig
+  type t
+end) =
+struct
+  open Unchecked_types (CohT) (TmT)
+
+  module Make (Coh : sig
+    val to_string : CohT.t -> string
+    val func_data : CohT.t -> (Var.t * int) list list
+  end) (Tm : sig
+    val func_data : TmT.t -> (Var.t * int) list list option
+    val name : TmT.t -> string option
+  end) =
+  struct
+    module Regular = struct
+      let rec func_to_string func =
+        let rec print_list = function
+          | [] -> ""
+          | [ (x, n) ] -> Printf.sprintf "(%s,%d)" (Var.to_string x) n
+          | (x, n) :: l ->
+              Printf.sprintf "%s (%s,%d)" (print_list l) (Var.to_string x) n
+        in
+        match func with
+        | [] -> ""
+        | l :: func ->
+            Printf.sprintf "%s[%s]" (func_to_string func) (print_list l)
+
+      let rec bracket i s =
+        if i <= 0 then s else Printf.sprintf "[%s]" (bracket (i - 1) s)
+
+      let rec ps_to_string = function
+        | Br l ->
+            Printf.sprintf "[%s]"
+              (List.fold_left
+                 (fun s ps -> Printf.sprintf "%s%s" (ps_to_string ps) s)
+                 "" l)
+
+      let rec ty_to_string = function
+        | Meta_ty i -> Printf.sprintf "_ty%i" i
+        | Obj -> "*"
+        | Arr (a, u, v) ->
+            if !Settings.verbosity >= 3 then
+              Printf.sprintf "%s | %s -> %s" (ty_to_string a) (tm_to_string u)
+                (tm_to_string v)
+            else Printf.sprintf "%s -> %s" (tm_to_string u) (tm_to_string v)
+
+      and tm_to_string = function
+        | Var v -> Var.to_string v
+        | Meta_tm i -> Printf.sprintf "_tm%i" i
+        | Coh (c, s) ->
+            if !Settings.unroll_coherences then
+              Printf.sprintf "%s[%s]" (Coh.to_string c) (sub_ps_to_string s)
+            else
+              let func = Coh.func_data c in
+              Printf.sprintf "(%s%s)" (Coh.to_string c)
+                (sub_ps_to_string ~func s)
+        | App (t, s) ->
+            let name =
+              match Tm.name t with Some name -> name | None -> "anonymous_tm"
+            in
+            let func = Tm.func_data t in
+            let str_s, expl = sub_to_string ?func s in
+            let expl_str = if expl then "@" else "" in
+            Printf.sprintf "(%s%s%s)" expl_str name str_s
+
+      and sub_ps_to_string ?(func = []) s =
+        match func with
+        | [] -> sub_ps_to_string_nofunc s
+        | func :: _ -> sub_ps_to_string_func s func
+
+      and sub_ps_to_string_nofunc s =
+        match s with
+        | [] -> ""
+        | (t, expl) :: s ->
+            if expl || !Settings.print_explicit_substitutions then
+              Printf.sprintf "%s %s" (sub_ps_to_string s) (tm_to_string t)
+            else sub_ps_to_string s
+
+      and sub_ps_to_string_func s func =
+        let rec print s =
+          match s with
+          | (t, true) :: s ->
+              let str, x = print s in
+              let arg =
+                match List.assoc_opt (Var.Db x) func with
+                | None -> tm_to_string t
+                | Some i -> bracket i (tm_to_string t)
+              in
+              (Printf.sprintf "%s %s" str arg, x + 1)
+          | (t, false) :: s ->
+              let str, x = print s in
+              let str =
+                if !Settings.print_explicit_substitutions then
+                  Printf.sprintf "%s %s" str (tm_to_string t)
+                else str
+              in
+              (str, x + 1)
+          | [] -> ("", 0)
+        in
+        fst (print s)
+
+      and sub_to_string ?(func = []) sub =
+        match func with
+        | [] -> (sub_to_string_nofunc sub, false)
+        | func :: _ ->
+            let s, b = sub_to_string_func sub func in
+            (" " ^ s, b)
+
+      and sub_to_string_nofunc sub =
+        match sub with
+        | [] -> ""
+        | (_, (t, expl)) :: s ->
+            if expl || !Settings.print_explicit_substitutions then
+              Printf.sprintf "%s %s" (sub_to_string_nofunc s) (tm_to_string t)
+            else sub_to_string_nofunc s
+
+      and sub_to_string_func s func =
+        let arg_to_string t b =
+          if b || !Settings.print_explicit_substitutions then tm_to_string t
+          else "_"
+        in
+        let rec string_list s needs_expl skip =
+          match s with
+          | [] when skip <= 0 -> ([], needs_expl)
+          | (x, (t, e)) :: s when skip <= 0 -> (
+              match List.assoc_opt x func with
+              | None ->
+                  let l, b = string_list s needs_expl 0 in
+                  ((arg_to_string t e, e) :: l, b)
+              | Some i ->
+                  let l, b = string_list s (needs_expl || not e) (2 * i) in
+                  ((bracket i (arg_to_string t e), e) :: l, b))
+          | _ :: s -> string_list s needs_expl (skip - 1)
+          | [] ->
+              Error.fatal
+                "functorialised arguments present in inconsistent places"
+        in
+        let str, needs_expl = string_list s false 0 in
+        let str =
+          List.rev_map
+            (fun (tm, e) -> if e || needs_expl then Some tm else None)
+            str
+        in
+        (String.concat " " (List.filter_map Fun.id str), needs_expl)
+
+      and sub_to_string_debug sub =
+        match sub with
+        | [] -> ""
+        | (x, (t, _)) :: s ->
+            Printf.sprintf "%s (%s, %s)" (sub_to_string_debug s)
+              (Var.to_string x) (tm_to_string t)
+
+      let pp_data_to_string ?(print_func = false) (name, susp, func) =
+        let susp_name =
+          if susp > 0 then Printf.sprintf "!%i%s" susp name else name
+        in
+        match func with
+        | [] -> susp_name
+        | _ :: [] when not print_func -> susp_name
+        | _ :: func when not print_func ->
+            susp_name ^ "_func" ^ func_to_string func
+        | func -> susp_name ^ "_func" ^ func_to_string func
+
+      let rec ctx_to_string = function
+        | [] -> ""
+        | (x, (t, true)) :: c ->
+            Printf.sprintf "%s (%s: %s)" (ctx_to_string c) (Var.to_string x)
+              (ty_to_string t)
+        | (x, (t, false)) :: c ->
+            Printf.sprintf "%s {%s: %s}" (ctx_to_string c) (Var.to_string x)
+              (ty_to_string t)
+
+      let rec meta_ctx_to_string = function
+        | [] -> ""
+        | (i, t) :: c ->
+            Printf.sprintf "%s (_tm%i: %s)" (meta_ctx_to_string c) i
+              (ty_to_string t)
+
+      let full_name name = pp_data_to_string ~print_func:true name
+    end
+
+    let ps_to_string = Regular.ps_to_string
+    let ty_to_string = Regular.ty_to_string
+    let tm_to_string = Regular.tm_to_string
+    let ctx_to_string = Regular.ctx_to_string
+    let sub_ps_to_string = Regular.sub_ps_to_string
+    let sub_to_string ?func s = fst (Regular.sub_to_string ?func s)
+    let sub_to_string_debug = Regular.sub_to_string_debug
+    let meta_ctx_to_string = Regular.meta_ctx_to_string
+    let pp_data_to_string = Regular.pp_data_to_string
+    let full_name = Regular.full_name
+  end
+end
diff --git a/lib/ps_reduction.ml b/lib/ps_reduction.ml
index a6aa3480..c1005c0f 100644
--- a/lib/ps_reduction.ml
+++ b/lib/ps_reduction.ml
@@ -28,7 +28,7 @@ let reduction_sub ps =
 
 let coh c =
   let ps, _, name = Coh.forget c in
-  let name = Unchecked.full_name name in
+  let name = Printing.full_name name in
   let ps = reduce (Unchecked.dim_ps ps - 1) ps in
   if Coh.is_inv c then Error.fatal "cannot reduce invertible coherences"
   else
diff --git a/lib/unchecked.ml b/lib/unchecked.ml
index 0abea270..2e3d08aa 100644
--- a/lib/unchecked.ml
+++ b/lib/unchecked.ml
@@ -29,6 +29,9 @@ struct
       TmT.t * Unchecked_types(CohT)(TmT).sub
   end) =
   struct
+    open Printing.Printing (CohT) (TmT)
+    module Printing = Make (Coh) (Tm)
+
     let sub_ps_to_sub s =
       let rec aux s =
         match s with
@@ -393,184 +396,6 @@ struct
           in
           wedge_sub_ps_bp ls
 
-    module Printing = struct
-      let rec func_to_string func =
-        let rec print_list = function
-          | [] -> ""
-          | [ (x, n) ] -> Printf.sprintf "(%s,%d)" (Var.to_string x) n
-          | (x, n) :: l ->
-              Printf.sprintf "%s (%s,%d)" (print_list l) (Var.to_string x) n
-        in
-        match func with
-        | [] -> ""
-        | l :: func ->
-            Printf.sprintf "%s[%s]" (func_to_string func) (print_list l)
-
-      let rec bracket i s =
-        if i <= 0 then s else Printf.sprintf "[%s]" (bracket (i - 1) s)
-
-      let rec ps_to_string = function
-        | Br l ->
-            Printf.sprintf "[%s]"
-              (List.fold_left
-                 (fun s ps -> Printf.sprintf "%s%s" (ps_to_string ps) s)
-                 "" l)
-
-      let rec ty_to_string = function
-        | Meta_ty i -> Printf.sprintf "_ty%i" i
-        | Obj -> "*"
-        | Arr (a, u, v) ->
-            if !Settings.verbosity >= 3 then
-              Printf.sprintf "%s | %s -> %s" (ty_to_string a) (tm_to_string u)
-                (tm_to_string v)
-            else Printf.sprintf "%s -> %s" (tm_to_string u) (tm_to_string v)
-
-      and tm_to_string = function
-        | Var v -> Var.to_string v
-        | Meta_tm i -> Printf.sprintf "_tm%i" i
-        | Coh (c, s) ->
-            if !Settings.unroll_coherences then
-              Printf.sprintf "%s[%s]" (Coh.to_string c) (sub_ps_to_string s)
-            else
-              let func = Coh.func_data c in
-              Printf.sprintf "(%s%s)" (Coh.to_string c)
-                (sub_ps_to_string ~func s)
-        | App (t, s) -> (
-            match Tm.name t with
-            | Some name ->
-                let func = Tm.func_data t in
-                let str_s, expl = sub_to_string ?func s in
-                let expl_str = if expl then "@" else "" in
-                Printf.sprintf "(%s%s%s)" expl_str name str_s
-            | None -> tm_to_string (tm_apply_sub (Tm.develop t) s))
-
-      and sub_ps_to_string ?(func = []) s =
-        match func with
-        | [] -> sub_ps_to_string_nofunc s
-        | func :: _ -> sub_ps_to_string_func s func
-
-      and sub_ps_to_string_nofunc s =
-        match s with
-        | [] -> ""
-        | (t, expl) :: s ->
-            if expl || !Settings.print_explicit_substitutions then
-              Printf.sprintf "%s %s" (sub_ps_to_string s) (tm_to_string t)
-            else sub_ps_to_string s
-
-      and sub_ps_to_string_func s func =
-        let rec print s =
-          match s with
-          | (t, true) :: s ->
-              let str, x = print s in
-              let arg =
-                match List.assoc_opt (Var.Db x) func with
-                | None -> tm_to_string t
-                | Some i -> bracket i (tm_to_string t)
-              in
-              (Printf.sprintf "%s %s" str arg, x + 1)
-          | (t, false) :: s ->
-              let str, x = print s in
-              let str =
-                if !Settings.print_explicit_substitutions then
-                  Printf.sprintf "%s %s" str (tm_to_string t)
-                else str
-              in
-              (str, x + 1)
-          | [] -> ("", 0)
-        in
-        fst (print s)
-
-      and sub_to_string ?(func = []) sub =
-        match func with
-        | [] -> (sub_to_string_nofunc sub, false)
-        | func :: _ ->
-            let s, b = sub_to_string_func sub func in
-            (" " ^ s, b)
-
-      and sub_to_string_nofunc sub =
-        match sub with
-        | [] -> ""
-        | (_, (t, expl)) :: s ->
-            if expl || !Settings.print_explicit_substitutions then
-              Printf.sprintf "%s %s" (sub_to_string_nofunc s) (tm_to_string t)
-            else sub_to_string_nofunc s
-
-      and sub_to_string_func s func =
-        let arg_to_string t b =
-          if b || !Settings.print_explicit_substitutions then tm_to_string t
-          else "_"
-        in
-        let rec string_list s needs_expl skip =
-          match s with
-          | [] when skip <= 0 -> ([], needs_expl)
-          | (x, (t, e)) :: s when skip <= 0 -> (
-              match List.assoc_opt x func with
-              | None ->
-                  let l, b = string_list s needs_expl 0 in
-                  ((arg_to_string t e, e) :: l, b)
-              | Some i ->
-                  let l, b = string_list s (needs_expl || not e) (2 * i) in
-                  ((bracket i (arg_to_string t e), e) :: l, b))
-          | _ :: s -> string_list s needs_expl (skip - 1)
-          | [] ->
-              Error.fatal
-                "functorialised arguments present in inconsistent places"
-        in
-        let str, needs_expl = string_list s false 0 in
-        let str =
-          List.rev_map
-            (fun (tm, e) -> if e || needs_expl then Some tm else None)
-            str
-        in
-        (String.concat " " (List.filter_map Fun.id str), needs_expl)
-
-      and sub_to_string_debug sub =
-        match sub with
-        | [] -> ""
-        | (x, (t, _)) :: s ->
-            Printf.sprintf "%s (%s, %s)" (sub_to_string_debug s)
-              (Var.to_string x) (tm_to_string t)
-
-      let pp_data_to_string ?(print_func = false) (name, susp, func) =
-        let susp_name =
-          if susp > 0 then Printf.sprintf "!%i%s" susp name else name
-        in
-        match func with
-        | [] -> susp_name
-        | _ :: [] when not print_func -> susp_name
-        | _ :: func when not print_func ->
-            susp_name ^ "_func" ^ func_to_string func
-        | func -> susp_name ^ "_func" ^ func_to_string func
-
-      let rec ctx_to_string = function
-        | [] -> ""
-        | (x, (t, true)) :: c ->
-            Printf.sprintf "%s (%s: %s)" (ctx_to_string c) (Var.to_string x)
-              (ty_to_string t)
-        | (x, (t, false)) :: c ->
-            Printf.sprintf "%s {%s: %s}" (ctx_to_string c) (Var.to_string x)
-              (ty_to_string t)
-
-      let rec meta_ctx_to_string = function
-        | [] -> ""
-        | (i, t) :: c ->
-            Printf.sprintf "%s (_tm%i: %s)" (meta_ctx_to_string c) i
-              (ty_to_string t)
-
-      let full_name name = pp_data_to_string ~print_func:true name
-    end
-
-    let ps_to_string = Printing.ps_to_string
-    let ty_to_string = Printing.ty_to_string
-    let tm_to_string = Printing.tm_to_string
-    let ctx_to_string = Printing.ctx_to_string
-    let sub_ps_to_string = Printing.sub_ps_to_string
-    let sub_to_string ?func s = fst (Printing.sub_to_string ?func s)
-    let sub_to_string_debug = Printing.sub_to_string_debug
-    let meta_ctx_to_string = Printing.meta_ctx_to_string
-    let pp_data_to_string = Printing.pp_data_to_string
-    let full_name = Printing.full_name
-
     let rec tm_contains_var t x =
       match t with
       | Var v -> v = x
@@ -598,7 +423,8 @@ struct
           check_equal_ps ps1 ps2;
           List.iter2 check_equal_ps l1 l2
       | Br [], Br (_ :: _) | Br (_ :: _), Br [] ->
-          raise (NotEqual (ps_to_string ps1, ps_to_string ps2))
+          raise
+            (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
 
     let rec check_equal_ty ty1 ty2 =
       match (ty1, ty2) with
@@ -615,7 +441,8 @@ struct
       | Meta_ty _, Arr _
       | Obj, Meta_ty _
       | Arr _, Meta_ty _ ->
-          raise (NotEqual (ty_to_string ty1, ty_to_string ty2))
+          raise
+            (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
 
     and check_equal_tm tm1 tm2 =
       match (tm1, tm2) with
@@ -639,7 +466,8 @@ struct
       | Coh _, Meta_tm _
       | App _, Meta_tm _
       | Meta_tm _, App _ ->
-          raise (NotEqual (tm_to_string tm1, tm_to_string tm2))
+          raise
+            (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
 
     and check_equal_sub_ps s1 s2 =
       List.iter2 (fun (t1, _) (t2, _) -> check_equal_tm t1 t2) s1 s2
@@ -659,7 +487,8 @@ struct
           check_equal_ty t1 t2;
           check_equal_ctx c1 c2
       | _ :: _, [] | [], _ :: _ ->
-          raise (NotEqual (ctx_to_string ctx1, ctx_to_string ctx2))
+          raise
+            (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
 
     let check_equal_ty ty1 ty2 =
       if ty1 == ty2 then () else check_equal_ty ty1 ty2
diff --git a/lib/unchecked.mli b/lib/unchecked.mli
index 9c69a95a..f5353d9c 100644
--- a/lib/unchecked.mli
+++ b/lib/unchecked.mli
@@ -28,16 +28,6 @@ end) : sig
   end) : sig
     type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
 
-    val ps_to_string : ps -> string
-    val ty_to_string : ty -> string
-    val tm_to_string : tm -> string
-    val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
-    val ctx_to_string : ctx -> string
-    val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
-    val sub_to_string_debug : sub -> string
-    val meta_ctx_to_string : meta_ctx -> string
-    val pp_data_to_string : ?print_func:bool -> pp_data -> string
-    val full_name : pp_data -> string
     val check_equal_ctx : ctx -> ctx -> unit
     val check_equal_ps : ps -> ps -> unit
     val check_equal_ty : ty -> ty -> unit

From 8e0083caad1cc76de57fafd859583a8d6b88bd97 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 30 Sep 2025 17:53:53 +0200
Subject: [PATCH 08/30] [refactor] separate module for equality testing

---
 lib/equality.ml   | 124 ++++++++++++++++++++++++++++++++++++++++++++++
 lib/kernel.ml     |  15 ++++--
 lib/kernel.mli    |  11 ++--
 lib/unchecked.ml  |  94 -----------------------------------
 lib/unchecked.mli |  10 ----
 5 files changed, 143 insertions(+), 111 deletions(-)
 create mode 100644 lib/equality.ml

diff --git a/lib/equality.ml b/lib/equality.ml
new file mode 100644
index 00000000..3c9b0def
--- /dev/null
+++ b/lib/equality.ml
@@ -0,0 +1,124 @@
+open Std
+open Common
+open Unchecked_types
+
+module Equality (CohT : sig
+  type t
+end) (TmT : sig
+  type t
+end) =
+struct
+  open Unchecked_types (CohT) (TmT)
+
+  module Make (Coh : sig
+    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
+    val to_string : CohT.t -> string
+    val func_data : CohT.t -> (Var.t * int) list list
+    val check_equal : CohT.t -> CohT.t -> unit
+    val check : ps -> ty -> pp_data -> CohT.t
+  end) (Tm : sig
+    val func_data : TmT.t -> (Var.t * int) list list option
+    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
+    val name : TmT.t -> string option
+
+    val apply :
+      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
+      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
+      (pp_data -> pp_data) ->
+      TmT.t ->
+      TmT.t * Unchecked_types(CohT)(TmT).sub
+  end) =
+  struct
+    module P = Printing.Printing (CohT) (TmT)
+    module Printing = P.Make (Coh) (Tm)
+    module U = Unchecked.Unchecked (CohT) (TmT)
+    module Unchecked = U.Make (Coh) (Tm)
+
+    let rec check_equal_ps ps1 ps2 =
+      match (ps1, ps2) with
+      | Br [], Br [] -> ()
+      | Br (ps1 :: l1), Br (ps2 :: l2) ->
+          check_equal_ps ps1 ps2;
+          List.iter2 check_equal_ps l1 l2
+      | Br [], Br (_ :: _) | Br (_ :: _), Br [] ->
+          raise
+            (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
+
+    let rec check_equal_ty ty1 ty2 =
+      match (ty1, ty2) with
+      | Meta_ty i, Meta_ty j ->
+          if i <> j then raise (NotEqual (string_of_int i, string_of_int j))
+      | Obj, Obj -> ()
+      | Arr (ty1, u1, v1), Arr (ty2, u2, v2) ->
+          check_equal_ty ty1 ty2;
+          check_equal_tm u1 u2;
+          check_equal_tm v1 v2
+      | Obj, Arr _
+      | Arr _, Obj
+      | Meta_ty _, Obj
+      | Meta_ty _, Arr _
+      | Obj, Meta_ty _
+      | Arr _, Meta_ty _ ->
+          raise
+            (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
+
+    and check_equal_tm tm1 tm2 =
+      match (tm1, tm2) with
+      | Var v1, Var v2 -> Var.check_equal v1 v2
+      | Meta_tm i, Meta_tm j ->
+          if i <> j then raise (NotEqual (string_of_int i, string_of_int j))
+      | Coh (coh1, s1), Coh (coh2, s2) ->
+          Coh.check_equal coh1 coh2;
+          check_equal_sub_ps s1 s2
+      | App (t1, s1), App (t2, s2) when t1 == t2 ->
+          check_equal_sub_on_support t1 s1 s2
+      | App (t, s), ((Coh _ | App _ | Var _) as tm2)
+      | ((Coh _ | Var _) as tm2), App (t, s) ->
+          let c = Tm.develop t in
+          check_equal_tm (Unchecked.tm_apply_sub c s) tm2
+      | Var _, Coh _
+      | Coh _, Var _
+      | Meta_tm _, Var _
+      | Meta_tm _, Coh _
+      | Var _, Meta_tm _
+      | Coh _, Meta_tm _
+      | App _, Meta_tm _
+      | Meta_tm _, App _ ->
+          raise
+            (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
+
+    and check_equal_sub_ps s1 s2 =
+      List.iter2 (fun (t1, _) (t2, _) -> check_equal_tm t1 t2) s1 s2
+
+    and check_equal_sub_on_support t s1 s2 =
+      List.iter2
+        (fun (x, (t1, _)) (y, (t2, _)) ->
+          Var.check_equal x y;
+          if Unchecked.tm_contains_var (Tm.develop t) x then
+            check_equal_tm t1 t2)
+        s1 s2
+
+    let rec check_equal_ctx ctx1 ctx2 =
+      match (ctx1, ctx2) with
+      | [], [] -> ()
+      | (v1, (t1, _)) :: c1, (v2, (t2, _)) :: c2 ->
+          Var.check_equal v1 v2;
+          check_equal_ty t1 t2;
+          check_equal_ctx c1 c2
+      | _ :: _, [] | [], _ :: _ ->
+          raise
+            (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
+
+    let check_equal_ty ty1 ty2 =
+      if ty1 == ty2 then () else check_equal_ty ty1 ty2
+
+    let check_equal_tm tm1 tm2 =
+      if tm1 == tm2 then () else check_equal_tm tm1 tm2
+
+    let check_equal_sub_ps s1 s2 =
+      if s1 == s2 then () else check_equal_sub_ps s1 s2
+
+    let check_equal_ctx ctx1 ctx2 =
+      if ctx1 == ctx2 then () else check_equal_ctx ctx1 ctx2
+  end
+end
diff --git a/lib/kernel.ml b/lib/kernel.ml
index 46a9492b..dc798abb 100644
--- a/lib/kernel.ml
+++ b/lib/kernel.ml
@@ -3,6 +3,7 @@ open Common
 open Unchecked_types
 open Unchecked
 open Printing
+open Equality
 
 exception IsObj
 exception IsCoh
@@ -105,6 +106,8 @@ end = struct
   module Unchecked = Make (Coh) (Tm)
   open Printing (Coh) (Tm)
   module Printing = Make (Coh) (Tm)
+  open Equality (Coh) (Tm)
+  module Equality = Make (Coh) (Tm)
 
   let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
@@ -126,7 +129,7 @@ end = struct
 
   let check_equal ctx1 ctx2 =
     if ctx1 == ctx2 then ()
-    else Unchecked.check_equal_ctx (forget ctx1) (forget ctx2)
+    else Equality.check_equal_ctx (forget ctx1) (forget ctx2)
 
   let check_notin ctx x =
     try
@@ -176,6 +179,8 @@ end = struct
   module Unchecked = Make (Coh) (Tm)
   open Printing (Coh) (Tm)
   module Printing = Make (Coh) (Tm)
+  open Equality (Coh) (Tm)
+  module Equality = Make (Coh) (Tm)
 
   (** A pasting scheme. *)
   type ps_derivation =
@@ -307,7 +312,7 @@ end = struct
 
   let check_equal ps1 ps2 =
     if ps1.tree == ps2.tree then ()
-    else Unchecked.check_equal_ps ps1.tree ps2.tree
+    else Equality.check_equal_ps ps1.tree ps2.tree
 end
 
 and Ty : sig
@@ -334,6 +339,8 @@ end = struct
   module Types = Unchecked_types (Coh) (Tm)
   open Printing (Coh) (Tm)
   module Printing = Make (Coh) (Tm)
+  open Equality (Coh) (Tm)
+  module Equality = Make (Coh) (Tm)
 
   (** A type exepression. *)
   type expr = Obj | Arr of t * Tm.t * Tm.t
@@ -386,7 +393,7 @@ end = struct
   (** Test for equality. *)
   let check_equal ty1 ty2 =
     Ctx.check_equal ty1.c ty2.c;
-    Unchecked.check_equal_ty (forget ty1) (forget ty2)
+    Equality.check_equal_ty (forget ty1) (forget ty2)
 
   let morphism t1 t2 =
     let a1 = Tm.typ t1 in
@@ -811,6 +818,8 @@ module Unchecked = U.Make (Coh) (Tm)
 module Display_maps = Unchecked.Display_maps
 module P = Printing (Coh) (Tm)
 module Printing = P.Make (Coh) (Tm)
+module E = Equality (Coh) (Tm)
+module Equality = E.Make (Coh) (Tm)
 
 let check check_fn name =
   let v = 2 in
diff --git a/lib/kernel.mli b/lib/kernel.mli
index 48ed2d3a..2e78ffbe 100644
--- a/lib/kernel.mli
+++ b/lib/kernel.mli
@@ -100,10 +100,6 @@ end
 module Unchecked : sig
   type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
 
-  val check_equal_ctx : ctx -> ctx -> unit
-  val check_equal_ps : ps -> ps -> unit
-  val check_equal_ty : ty -> ty -> unit
-  val check_equal_tm : tm -> tm -> unit
   val dim_ctx : ctx -> int
   val dim_ty : ty -> int
   val dim_ps : ps -> int
@@ -177,6 +173,13 @@ module Printing : sig
   val full_name : pp_data -> string
 end
 
+module Equality : sig
+  val check_equal_ctx : ctx -> ctx -> unit
+  val check_equal_ps : ps -> ps -> unit
+  val check_equal_ty : ty -> ty -> unit
+  val check_equal_tm : tm -> tm -> unit
+end
+
 module Display_maps : sig
   val var_apply_sub : Var.t -> sub -> Var.t
   val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
diff --git a/lib/unchecked.ml b/lib/unchecked.ml
index 2e3d08aa..0d59100e 100644
--- a/lib/unchecked.ml
+++ b/lib/unchecked.ml
@@ -12,13 +12,8 @@ struct
 
   module Make (Coh : sig
     val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
-    val to_string : CohT.t -> string
-    val func_data : CohT.t -> (Var.t * int) list list
-    val check_equal : CohT.t -> CohT.t -> unit
     val check : ps -> ty -> pp_data -> CohT.t
   end) (Tm : sig
-    val name : TmT.t -> string option
-    val func_data : TmT.t -> (Var.t * int) list list option
     val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
 
     val apply :
@@ -29,9 +24,6 @@ struct
       TmT.t * Unchecked_types(CohT)(TmT).sub
   end) =
   struct
-    open Printing.Printing (CohT) (TmT)
-    module Printing = Make (Coh) (Tm)
-
     let sub_ps_to_sub s =
       let rec aux s =
         match s with
@@ -416,92 +408,6 @@ struct
 
     let tm_contains_vars t l = List.exists (tm_contains_var t) l
 
-    let rec check_equal_ps ps1 ps2 =
-      match (ps1, ps2) with
-      | Br [], Br [] -> ()
-      | Br (ps1 :: l1), Br (ps2 :: l2) ->
-          check_equal_ps ps1 ps2;
-          List.iter2 check_equal_ps l1 l2
-      | Br [], Br (_ :: _) | Br (_ :: _), Br [] ->
-          raise
-            (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
-
-    let rec check_equal_ty ty1 ty2 =
-      match (ty1, ty2) with
-      | Meta_ty i, Meta_ty j ->
-          if i <> j then raise (NotEqual (string_of_int i, string_of_int j))
-      | Obj, Obj -> ()
-      | Arr (ty1, u1, v1), Arr (ty2, u2, v2) ->
-          check_equal_ty ty1 ty2;
-          check_equal_tm u1 u2;
-          check_equal_tm v1 v2
-      | Obj, Arr _
-      | Arr _, Obj
-      | Meta_ty _, Obj
-      | Meta_ty _, Arr _
-      | Obj, Meta_ty _
-      | Arr _, Meta_ty _ ->
-          raise
-            (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
-
-    and check_equal_tm tm1 tm2 =
-      match (tm1, tm2) with
-      | Var v1, Var v2 -> Var.check_equal v1 v2
-      | Meta_tm i, Meta_tm j ->
-          if i <> j then raise (NotEqual (string_of_int i, string_of_int j))
-      | Coh (coh1, s1), Coh (coh2, s2) ->
-          Coh.check_equal coh1 coh2;
-          check_equal_sub_ps s1 s2
-      | App (t1, s1), App (t2, s2) when t1 == t2 ->
-          check_equal_sub_on_support t1 s1 s2
-      | App (t, s), ((Coh _ | App _ | Var _) as tm2)
-      | ((Coh _ | Var _) as tm2), App (t, s) ->
-          let c = Tm.develop t in
-          check_equal_tm (tm_apply_sub c s) tm2
-      | Var _, Coh _
-      | Coh _, Var _
-      | Meta_tm _, Var _
-      | Meta_tm _, Coh _
-      | Var _, Meta_tm _
-      | Coh _, Meta_tm _
-      | App _, Meta_tm _
-      | Meta_tm _, App _ ->
-          raise
-            (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
-
-    and check_equal_sub_ps s1 s2 =
-      List.iter2 (fun (t1, _) (t2, _) -> check_equal_tm t1 t2) s1 s2
-
-    and check_equal_sub_on_support t s1 s2 =
-      List.iter2
-        (fun (x, (t1, _)) (y, (t2, _)) ->
-          Var.check_equal x y;
-          if tm_contains_var (Tm.develop t) x then check_equal_tm t1 t2)
-        s1 s2
-
-    let rec check_equal_ctx ctx1 ctx2 =
-      match (ctx1, ctx2) with
-      | [], [] -> ()
-      | (v1, (t1, _)) :: c1, (v2, (t2, _)) :: c2 ->
-          Var.check_equal v1 v2;
-          check_equal_ty t1 t2;
-          check_equal_ctx c1 c2
-      | _ :: _, [] | [], _ :: _ ->
-          raise
-            (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
-
-    let check_equal_ty ty1 ty2 =
-      if ty1 == ty2 then () else check_equal_ty ty1 ty2
-
-    let check_equal_tm tm1 tm2 =
-      if tm1 == tm2 then () else check_equal_tm tm1 tm2
-
-    let check_equal_sub_ps s1 s2 =
-      if s1 == s2 then () else check_equal_sub_ps s1 s2
-
-    let check_equal_ctx ctx1 ctx2 =
-      if ctx1 == ctx2 then () else check_equal_ctx ctx1 ctx2
-
     let rec list_to_sub s ctx =
       match (s, ctx) with
       | t :: s, (x, (_, expl)) :: ctx -> (x, (t, expl)) :: list_to_sub s ctx
diff --git a/lib/unchecked.mli b/lib/unchecked.mli
index f5353d9c..dbf3967b 100644
--- a/lib/unchecked.mli
+++ b/lib/unchecked.mli
@@ -10,13 +10,8 @@ end) : sig
 
   module Make (_ : sig
     val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
-    val to_string : Coh.t -> string
-    val func_data : Coh.t -> (Var.t * int) list list
-    val check_equal : Coh.t -> Coh.t -> unit
     val check : ps -> ty -> pp_data -> Coh.t
   end) (_ : sig
-    val name : Tm.t -> string option
-    val func_data : Tm.t -> (Var.t * int) list list option
     val develop : Tm.t -> Unchecked_types(Coh)(Tm).tm
 
     val apply :
@@ -28,11 +23,6 @@ end) : sig
   end) : sig
     type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
 
-    val check_equal_ctx : ctx -> ctx -> unit
-    val check_equal_ps : ps -> ps -> unit
-    val check_equal_ty : ty -> ty -> unit
-    val check_equal_tm : tm -> tm -> unit
-    val check_equal_sub_ps : sub_ps -> sub_ps -> unit
     val dim_ctx : ctx -> int
     val dim_ty : ty -> int
     val dim_ps : ps -> int

From 6b3e9288caa3f73bc765e47a415566e598360102 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 30 Sep 2025 18:39:12 +0200
Subject: [PATCH 09/30] [printing] add is_equal function to test equality

---
 lib/common.ml   | 15 ++++----
 lib/common.mli  |  2 +-
 lib/equality.ml | 96 +++++++++++++++++++++++++------------------------
 lib/kernel.ml   | 54 +++++++++++++++++-----------
 4 files changed, 91 insertions(+), 76 deletions(-)

diff --git a/lib/common.ml b/lib/common.ml
index 5cc4273b..4e4448fc 100644
--- a/lib/common.ml
+++ b/lib/common.ml
@@ -23,16 +23,13 @@ module Var = struct
 
   let make_var s = Name s
 
-  let rec check_equal v1 v2 =
+  let rec is_equal v1 v2 =
     match (v1, v2) with
-    | Name s1, Name s2 ->
-        if not (String.equal s1 s2) then raise (NotEqual (s1, s2)) else ()
-    | New i, New j ->
-        if i != j then raise (NotEqual (to_string v1, to_string v2)) else ()
-    | Db i, Db j ->
-        if i != j then raise (NotEqual (to_string v1, to_string v2)) else ()
-    | Plus v1, Plus v2 | Bridge v1, Bridge v2 -> check_equal v1 v2
-    | _, _ -> raise (NotEqual (to_string v1, to_string v2))
+    | Name s1, Name s2 -> String.equal s1 s2
+    | New i, New j -> i = j
+    | Db i, Db j -> i = j
+    | Plus v1, Plus v2 | Bridge v1, Bridge v2 -> is_equal v1 v2
+    | _, _ -> false
 
   let rec suspend_n v n =
     match v with
diff --git a/lib/common.mli b/lib/common.mli
index 5df20dc5..8fea4929 100644
--- a/lib/common.mli
+++ b/lib/common.mli
@@ -15,7 +15,7 @@ module Var : sig
 
   val to_string : t -> string
   val make_var : string -> t
-  val check_equal : t -> t -> unit
+  val is_equal : t -> t -> bool
   val suspend : t -> t
   val suspend_n : t -> int -> t
   val fresh : unit -> t
diff --git a/lib/equality.ml b/lib/equality.ml
index 3c9b0def..a4f323cc 100644
--- a/lib/equality.ml
+++ b/lib/equality.ml
@@ -14,7 +14,7 @@ struct
     val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
     val to_string : CohT.t -> string
     val func_data : CohT.t -> (Var.t * int) list list
-    val check_equal : CohT.t -> CohT.t -> unit
+    val is_equal : CohT.t -> CohT.t -> bool
     val check : ps -> ty -> pp_data -> CohT.t
   end) (Tm : sig
     val func_data : TmT.t -> (Var.t * int) list list option
@@ -34,48 +34,39 @@ struct
     module U = Unchecked.Unchecked (CohT) (TmT)
     module Unchecked = U.Make (Coh) (Tm)
 
-    let rec check_equal_ps ps1 ps2 =
+    let rec is_equal_ps ps1 ps2 =
       match (ps1, ps2) with
-      | Br [], Br [] -> ()
+      | Br [], Br [] -> true
       | Br (ps1 :: l1), Br (ps2 :: l2) ->
-          check_equal_ps ps1 ps2;
-          List.iter2 check_equal_ps l1 l2
-      | Br [], Br (_ :: _) | Br (_ :: _), Br [] ->
-          raise
-            (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
+          is_equal_ps ps1 ps2 && List.for_all2 is_equal_ps l1 l2
+      | Br [], Br (_ :: _) | Br (_ :: _), Br [] -> false
 
-    let rec check_equal_ty ty1 ty2 =
+    let rec is_equal_ty ty1 ty2 =
       match (ty1, ty2) with
-      | Meta_ty i, Meta_ty j ->
-          if i <> j then raise (NotEqual (string_of_int i, string_of_int j))
-      | Obj, Obj -> ()
+      | Meta_ty i, Meta_ty j -> i = j
+      | Obj, Obj -> true
       | Arr (ty1, u1, v1), Arr (ty2, u2, v2) ->
-          check_equal_ty ty1 ty2;
-          check_equal_tm u1 u2;
-          check_equal_tm v1 v2
+          is_equal_ty ty1 ty2 && is_equal_tm u1 u2 && is_equal_tm v1 v2
       | Obj, Arr _
       | Arr _, Obj
       | Meta_ty _, Obj
       | Meta_ty _, Arr _
       | Obj, Meta_ty _
       | Arr _, Meta_ty _ ->
-          raise
-            (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
+          false
 
-    and check_equal_tm tm1 tm2 =
+    and is_equal_tm tm1 tm2 =
       match (tm1, tm2) with
-      | Var v1, Var v2 -> Var.check_equal v1 v2
-      | Meta_tm i, Meta_tm j ->
-          if i <> j then raise (NotEqual (string_of_int i, string_of_int j))
+      | Var v1, Var v2 -> Var.is_equal v1 v2
+      | Meta_tm i, Meta_tm j -> i = j
       | Coh (coh1, s1), Coh (coh2, s2) ->
-          Coh.check_equal coh1 coh2;
-          check_equal_sub_ps s1 s2
+          Coh.is_equal coh1 coh2 && is_equal_sub_ps s1 s2
       | App (t1, s1), App (t2, s2) when t1 == t2 ->
-          check_equal_sub_on_support t1 s1 s2
+          is_equal_sub_on_support t1 s1 s2
       | App (t, s), ((Coh _ | App _ | Var _) as tm2)
       | ((Coh _ | Var _) as tm2), App (t, s) ->
           let c = Tm.develop t in
-          check_equal_tm (Unchecked.tm_apply_sub c s) tm2
+          is_equal_tm (Unchecked.tm_apply_sub c s) tm2
       | Var _, Coh _
       | Coh _, Var _
       | Meta_tm _, Var _
@@ -84,41 +75,54 @@ struct
       | Coh _, Meta_tm _
       | App _, Meta_tm _
       | Meta_tm _, App _ ->
-          raise
-            (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
+          false
 
-    and check_equal_sub_ps s1 s2 =
-      List.iter2 (fun (t1, _) (t2, _) -> check_equal_tm t1 t2) s1 s2
+    and is_equal_sub_ps s1 s2 =
+      List.for_all2 (fun (t1, _) (t2, _) -> is_equal_tm t1 t2) s1 s2
 
-    and check_equal_sub_on_support t s1 s2 =
-      List.iter2
+    and is_equal_sub_on_support t s1 s2 =
+      List.for_all2
         (fun (x, (t1, _)) (y, (t2, _)) ->
-          Var.check_equal x y;
-          if Unchecked.tm_contains_var (Tm.develop t) x then
-            check_equal_tm t1 t2)
+          Var.is_equal x y
+          && ((not (Unchecked.tm_contains_var (Tm.develop t) x))
+             || is_equal_tm t1 t2))
         s1 s2
 
-    let rec check_equal_ctx ctx1 ctx2 =
+    let rec is_equal_ctx ctx1 ctx2 =
       match (ctx1, ctx2) with
-      | [], [] -> ()
+      | [], [] -> true
       | (v1, (t1, _)) :: c1, (v2, (t2, _)) :: c2 ->
-          Var.check_equal v1 v2;
-          check_equal_ty t1 t2;
-          check_equal_ctx c1 c2
-      | _ :: _, [] | [], _ :: _ ->
-          raise
-            (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
+          Var.is_equal v1 v2 && is_equal_ty t1 t2 && is_equal_ctx c1 c2
+      | _ :: _, [] | [], _ :: _ -> false
+
+    let is_equal_ps ps1 ps2 = ps1 == ps2 || is_equal_ps ps1 ps2
+    let is_equal_ty ty1 ty2 = ty1 == ty2 || is_equal_ty ty1 ty2
+    let is_equal_tm tm1 tm2 = tm1 == tm2 || is_equal_tm tm1 tm2
+    let is_equal_sub_ps s1 s2 = s1 == s2 || is_equal_sub_ps s1 s2
+    let is_equal_ctx ctx1 ctx2 = ctx1 == ctx2 || is_equal_ctx ctx1 ctx2
 
     let check_equal_ty ty1 ty2 =
-      if ty1 == ty2 then () else check_equal_ty ty1 ty2
+      if not (is_equal_ty ty1 ty2) then
+        raise (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
 
     let check_equal_tm tm1 tm2 =
-      if tm1 == tm2 then () else check_equal_tm tm1 tm2
+      if not (is_equal_tm tm1 tm2) then
+        raise (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
 
     let check_equal_sub_ps s1 s2 =
-      if s1 == s2 then () else check_equal_sub_ps s1 s2
+      if not (is_equal_sub_ps s1 s2) then ()
+      else
+        raise
+          (NotEqual (Printing.sub_ps_to_string s1, Printing.sub_ps_to_string s2))
 
     let check_equal_ctx ctx1 ctx2 =
-      if ctx1 == ctx2 then () else check_equal_ctx ctx1 ctx2
+      if ctx1 == ctx2 || is_equal_ctx ctx1 ctx2 then ()
+      else
+        raise
+          (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
+
+    let check_equal_ps ps1 ps2 =
+      if not (is_equal_ps ps1 ps2) then
+        raise (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
   end
 end
diff --git a/lib/kernel.ml b/lib/kernel.ml
index dc798abb..91c86cc7 100644
--- a/lib/kernel.ml
+++ b/lib/kernel.ml
@@ -97,6 +97,7 @@ and Ctx : sig
   val forget : t -> Unchecked_types(Coh)(Tm).ctx
   val check : Unchecked_types(Coh)(Tm).ctx -> t
   val check_notin : t -> Var.t -> unit
+  val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
 end = struct
   type t = { c : (Var.t * Ty.t) list; unchecked : Unchecked_types(Coh)(Tm).ctx }
@@ -127,9 +128,15 @@ end = struct
   let forget c = c.unchecked
   let to_string ctx = Printing.ctx_to_string (forget ctx)
 
+  let is_equal ctx1 ctx2 =
+    ctx1 == ctx2 || Equality.is_equal_ctx (forget ctx1) (forget ctx2)
+
   let check_equal ctx1 ctx2 =
-    if ctx1 == ctx2 then ()
-    else Equality.check_equal_ctx (forget ctx1) (forget ctx2)
+    if not (is_equal ctx1 ctx2) then
+      raise
+        (NotEqual
+           ( Printing.ctx_to_string (forget ctx1),
+             Printing.ctx_to_string (forget ctx2) ))
 
   let check_notin ctx x =
     try
@@ -171,7 +178,7 @@ and PS : sig
   val source : t -> Sub.t
   val target : t -> Sub.t
   val forget : t -> ps
-  val check_equal : t -> t -> unit
+  val is_equal : t -> t -> bool
 end = struct
   exception Invalid
 
@@ -310,9 +317,8 @@ end = struct
   let target ps =
     Sub.check_to_ps (to_ctx ps) (Unchecked.ps_tgt ps.tree) (bdry ps)
 
-  let check_equal ps1 ps2 =
-    if ps1.tree == ps2.tree then ()
-    else Equality.check_equal_ps ps1.tree ps2.tree
+  let is_equal ps1 ps2 =
+    ps1.tree == ps2.tree || Equality.is_equal_ps ps1.tree ps2.tree
 end
 
 and Ty : sig
@@ -322,6 +328,7 @@ and Ty : sig
   val free_vars : t -> Var.t list
   val is_full : t -> bool
   val is_obj : t -> bool
+  val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
   val morphism : Tm.t -> Tm.t -> Ty.t
   val forget : t -> Unchecked_types(Coh)(Tm).ty
@@ -390,10 +397,15 @@ end = struct
   let forget t = t.unchecked
   let to_string ty = Printing.ty_to_string (forget ty)
 
-  (** Test for equality. *)
+  let is_equal ty1 ty2 =
+    Ctx.is_equal ty1.c ty2.c && Equality.is_equal_ty (forget ty1) (forget ty2)
+
   let check_equal ty1 ty2 =
-    Ctx.check_equal ty1.c ty2.c;
-    Equality.check_equal_ty (forget ty1) (forget ty2)
+    if not (is_equal ty1 ty2) then
+      raise
+        (NotEqual
+           ( Printing.ty_to_string (forget ty1),
+             Printing.ty_to_string (forget ty2) ))
 
   let morphism t1 t2 =
     let a1 = Tm.typ t1 in
@@ -623,6 +635,7 @@ and Coh : sig
 
   val forget : t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
   val func_data : t -> (Var.t * int) list list
+  val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
   val dim : t -> int
 
@@ -783,18 +796,19 @@ end = struct
     let ps, ty, pp_data = data c in
     (PS.forget ps, Ty.forget ty, pp_data)
 
+  let is_equal coh1 coh2 =
+    coh1 == coh2
+    ||
+    match (coh1, coh2) with
+    | Inv (d1, _), Inv (d2, _) ->
+        PS.is_equal d1.ps d2.ps && Ty.is_equal d1.ty d2.ty
+    | NonInv (d1, _), NonInv (d2, _) ->
+        PS.is_equal d1.ps d2.ps && Ty.is_equal d1.total_ty d2.total_ty
+    | Inv _, NonInv _ | NonInv _, Inv _ -> false
+
   let check_equal coh1 coh2 =
-    if coh1 == coh2 then ()
-    else
-      match (coh1, coh2) with
-      | Inv (d1, _), Inv (d2, _) ->
-          PS.check_equal d1.ps d2.ps;
-          Ty.check_equal d1.ty d2.ty
-      | NonInv (d1, _), NonInv (d2, _) ->
-          PS.check_equal d1.ps d2.ps;
-          Ty.check_equal d1.total_ty d2.total_ty
-      | Inv _, NonInv _ | NonInv _, Inv _ ->
-          raise (NotEqual (to_string coh1, to_string coh2))
+    if not (is_equal coh1 coh2) then
+      raise (NotEqual (to_string coh1, to_string coh2))
 
   let apply_ps fun_ps fun_ty fun_pp_data coh =
     let ps, ty, pp = forget coh in

From 9cb0f5183234589edcb17a69fa4c14b5a0792fc1 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 30 Sep 2025 18:47:10 +0200
Subject: [PATCH 10/30] [printing] implementation of kolmogorov complexity
 printing

---
 lib/command.ml                 |  20 ++++
 lib/command.mli                |   2 +
 lib/equality.ml                |  11 +-
 lib/equality.mli               |  42 +++++++
 lib/kernel.ml                  |  59 +++++-----
 lib/kernel.mli                 |   3 +-
 lib/lexer.mll                  |   3 +-
 lib/parser.mly                 |   4 +-
 lib/printing.ml                | 200 ++++++++++++++++++++++++++++++++-
 lib/printing.mli               |  36 ++++++
 test.t/features/benchmark.catt |   3 +
 11 files changed, 351 insertions(+), 32 deletions(-)
 create mode 100644 lib/equality.mli
 create mode 100644 lib/printing.mli
 create mode 100644 test.t/features/benchmark.catt

diff --git a/lib/command.ml b/lib/command.ml
index 5531d0ff..bd3367a7 100644
--- a/lib/command.ml
+++ b/lib/command.ml
@@ -15,6 +15,8 @@ type cmd =
   | Decl of Var.t * (Var.t * tyR) list * tmR * tyR option
   | Decl_builtin of Var.t * builtin
   | Set of string * string
+  | Benchmark of (Var.t * tyR) list * tmR
+  | Benchmark_builtin of builtin
 
 type prog = cmd list
 
@@ -133,6 +135,24 @@ let exec_cmd cmd =
           (Printf.sprintf "successfully defined term %s of type %s"
              (Environment.value_to_string e)
              (Printing.ty_to_string ty)))
+  | Benchmark (l, e) ->
+      let e, _ = check l e None in
+      Io.info
+        (lazy
+          (Printf.sprintf "term computes to:\n %s"
+             (Printing.print_kolmogorov e)))
+  | Benchmark_builtin b ->
+      let e, _ = exec_check_builtin b in
+      let e =
+        match e with
+        | Environment.Coh _ ->
+            Error.fatal "bechmarking a builtin resolving to a coherence"
+        | Environment.Tm e -> Tm.develop e
+      in
+      Io.info
+        (lazy
+          (Printf.sprintf "term computes to:\n %s"
+             (Printing.print_kolmogorov e)))
 
 type next = Abort | KeepGoing | Interactive
 
diff --git a/lib/command.mli b/lib/command.mli
index 50dfe613..ba22549b 100644
--- a/lib/command.mli
+++ b/lib/command.mli
@@ -10,6 +10,8 @@ type cmd =
   | Decl of Var.t * (Var.t * tyR) list * tmR * tyR option
   | Decl_builtin of Var.t * builtin
   | Set of string * string
+  | Benchmark of (Var.t * tyR) list * tmR
+  | Benchmark_builtin of builtin
 
 type prog = cmd list
 
diff --git a/lib/equality.ml b/lib/equality.ml
index a4f323cc..dd8549bc 100644
--- a/lib/equality.ml
+++ b/lib/equality.ml
@@ -12,7 +12,7 @@ struct
 
   module Make (Coh : sig
     val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
-    val to_string : CohT.t -> string
+    val to_string : ?unroll:bool -> CohT.t -> string
     val func_data : CohT.t -> (Var.t * int) list list
     val is_equal : CohT.t -> CohT.t -> bool
     val check : ps -> ty -> pp_data -> CohT.t
@@ -20,6 +20,9 @@ struct
     val func_data : TmT.t -> (Var.t * int) list list option
     val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
     val name : TmT.t -> string option
+    val full_name : TmT.t -> string option
+    val ctx : TmT.t -> ctx
+    val is_equal : TmT.t -> TmT.t -> bool
 
     val apply :
       (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
@@ -37,8 +40,10 @@ struct
     let rec is_equal_ps ps1 ps2 =
       match (ps1, ps2) with
       | Br [], Br [] -> true
-      | Br (ps1 :: l1), Br (ps2 :: l2) ->
-          is_equal_ps ps1 ps2 && List.for_all2 is_equal_ps l1 l2
+      | Br (ps1 :: l1), Br (ps2 :: l2) -> (
+          is_equal_ps ps1 ps2
+          &&
+          try List.for_all2 is_equal_ps l1 l2 with Invalid_argument _ -> true)
       | Br [], Br (_ :: _) | Br (_ :: _), Br [] -> false
 
     let rec is_equal_ty ty1 ty2 =
diff --git a/lib/equality.mli b/lib/equality.mli
new file mode 100644
index 00000000..922ac293
--- /dev/null
+++ b/lib/equality.mli
@@ -0,0 +1,42 @@
+open Common
+open Unchecked_types
+
+module Equality (Coh : sig
+  type t
+end) (Tm : sig
+  type t
+end) : sig
+  open Unchecked_types(Coh)(Tm)
+
+  module Make (_ : sig
+    val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
+    val to_string : ?unroll:bool -> Coh.t -> string
+    val func_data : Coh.t -> (Var.t * int) list list
+    val is_equal : Coh.t -> Coh.t -> bool
+    val check : ps -> ty -> pp_data -> Coh.t
+  end) (_ : sig
+    val func_data : Tm.t -> (Var.t * int) list list option
+    val develop : Tm.t -> Unchecked_types(Coh)(Tm).tm
+    val name : Tm.t -> string option
+    val full_name : Tm.t -> string option
+    val ctx : Tm.t -> ctx
+    val is_equal : Tm.t -> Tm.t -> bool
+
+    val apply :
+      (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
+      (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
+      (pp_data -> pp_data) ->
+      Tm.t ->
+      Tm.t * Unchecked_types(Coh)(Tm).sub
+  end) : sig
+    val check_equal_ctx : ctx -> ctx -> unit
+    val check_equal_ps : ps -> ps -> unit
+    val check_equal_ty : ty -> ty -> unit
+    val check_equal_tm : tm -> tm -> unit
+    val check_equal_sub_ps : sub_ps -> sub_ps -> unit
+    val is_equal_ctx : ctx -> ctx -> bool
+    val is_equal_ps : ps -> ps -> bool
+    val is_equal_ty : ty -> ty -> bool
+    val is_equal_tm : tm -> tm -> bool
+  end
+end
diff --git a/lib/kernel.ml b/lib/kernel.ml
index 91c86cc7..e35d5260 100644
--- a/lib/kernel.ml
+++ b/lib/kernel.ml
@@ -103,12 +103,12 @@ end = struct
   type t = { c : (Var.t * Ty.t) list; unchecked : Unchecked_types(Coh)(Tm).ctx }
 
   open Unchecked_types (Coh) (Tm)
-  open Unchecked (Coh) (Tm)
-  module Unchecked = Make (Coh) (Tm)
-  open Printing (Coh) (Tm)
-  module Printing = Make (Coh) (Tm)
-  open Equality (Coh) (Tm)
-  module Equality = Make (Coh) (Tm)
+  module U = Unchecked (Coh) (Tm)
+  module Unchecked = U.Make (Coh) (Tm)
+  module P = Printing (Coh) (Tm)
+  module Printing = P.Make (Coh) (Tm)
+  module E = Equality (Coh) (Tm)
+  module Equality = E.Make (Coh) (Tm)
 
   let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
@@ -182,12 +182,12 @@ and PS : sig
 end = struct
   exception Invalid
 
-  open Unchecked (Coh) (Tm)
-  module Unchecked = Make (Coh) (Tm)
-  open Printing (Coh) (Tm)
-  module Printing = Make (Coh) (Tm)
-  open Equality (Coh) (Tm)
-  module Equality = Make (Coh) (Tm)
+  module U = Unchecked (Coh) (Tm)
+  module Unchecked = U.Make (Coh) (Tm)
+  module P = Printing (Coh) (Tm)
+  module Printing = P.Make (Coh) (Tm)
+  module E = Equality (Coh) (Tm)
+  module Equality = E.Make (Coh) (Tm)
 
   (** A pasting scheme. *)
   type ps_derivation =
@@ -341,13 +341,13 @@ and Ty : sig
   val ctx : t -> Ctx.t
   val dim : t -> int
 end = struct
-  open Unchecked (Coh) (Tm)
-  module Unchecked = Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
-  open Printing (Coh) (Tm)
-  module Printing = Make (Coh) (Tm)
-  open Equality (Coh) (Tm)
-  module Equality = Make (Coh) (Tm)
+  module U = Unchecked (Coh) (Tm)
+  module Unchecked = U.Make (Coh) (Tm)
+  module P = Printing (Coh) (Tm)
+  module Printing = P.Make (Coh) (Tm)
+  module E = Equality (Coh) (Tm)
+  module Equality = E.Make (Coh) (Tm)
 
   (** A type exepression. *)
   type expr = Obj | Arr of t * Tm.t * Tm.t
@@ -463,13 +463,17 @@ and Tm : sig
     (pp_data -> pp_data) ->
     t ->
     t * Unchecked_types(Coh)(Tm).sub
+
+  val is_equal : t -> t -> bool
 end = struct
-  open Unchecked (Coh) (Tm)
-  module Unchecked = Make (Coh) (Tm)
+  module U = Unchecked (Coh) (Tm)
+  module Unchecked = U.Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
   module Display_maps = Unchecked.Display_maps
-  open Printing (Coh) (Tm)
-  module Printing = Make (Coh) (Tm)
+  module P = Printing (Coh) (Tm)
+  module Printing = P.Make (Coh) (Tm)
+  module E = Equality (Coh) (Tm)
+  module Equality = E.Make (Coh) (Tm)
 
   type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
 
@@ -567,6 +571,10 @@ end = struct
     let t = Unchecked.tm_sub_preimage (forget t) (Sub.forget sub) in
     check c t
 
+  let is_equal t1 t2 =
+    Ctx.is_equal (Ty.ctx t1.ty) (Ty.ctx t2.ty)
+    && Equality.is_equal_tm t1.unchecked t2.unchecked
+
   let apply fun_ctx fun_tm fun_pp_data tm =
     let c = fun_ctx (Ctx.forget (Ty.ctx (typ tm))) in
     let db_sub = Unchecked.db_level_sub_inv c in
@@ -624,7 +632,7 @@ and Coh : sig
     pp_data ->
     t
 
-  val to_string : t -> string
+  val to_string : ?unroll:bool -> t -> string
   val is_inv : t -> bool
 
   val noninv_srctgt :
@@ -774,9 +782,10 @@ end = struct
     | Inv (d, pp_data) -> (d.ps, d.ty, pp_data)
     | NonInv (d, pp_data) -> (d.ps, d.total_ty, pp_data)
 
-  let to_string c =
+  let to_string ?(unroll = false) c =
     let ps, ty, pp_data = data c in
-    if not !Settings.unroll_coherences then Printing.pp_data_to_string pp_data
+    if not (unroll || !Settings.unroll_coherences) then
+      Printing.pp_data_to_string pp_data
     else Printf.sprintf "Coh(%s,%s)" (PS.to_string ps) (Ty.to_string ty)
 
   let noninv_srctgt c =
diff --git a/lib/kernel.mli b/lib/kernel.mli
index 2e78ffbe..e4fd07d6 100644
--- a/lib/kernel.mli
+++ b/lib/kernel.mli
@@ -7,7 +7,7 @@ module rec Coh : sig
   val forget : t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
   val check_equal : t -> t -> unit
   val is_inv : t -> bool
-  val to_string : t -> string
+  val to_string : ?unroll:bool -> t -> string
   val dim : t -> int
   val src : t -> Unchecked_types(Coh)(Tm).tm
   val tgt : t -> Unchecked_types(Coh)(Tm).tm
@@ -171,6 +171,7 @@ module Printing : sig
   val meta_ctx_to_string : meta_ctx -> string
   val pp_data_to_string : ?print_func:bool -> pp_data -> string
   val full_name : pp_data -> string
+  val print_kolmogorov : tm -> string
 end
 
 module Equality : sig
diff --git a/lib/lexer.mll b/lib/lexer.mll
index 5f358713..b35f0f8e 100644
--- a/lib/lexer.mll
+++ b/lib/lexer.mll
@@ -33,8 +33,9 @@ rule token = parse
                                                                             let n = int_of_string n in
                                                                             let k = int_of_string k in
                                                                             let l = int_of_string l in
-                                                                            EH_HALF(n,k,l) }                                                                        
+                                                                            EH_HALF(n,k,l) }
   | "declare" { DECLARE }
+  | "benchmark" { BENCHMARK }
   | "I" { INV }
   | "U" { UNIT }
   | "(" { LPAR }
diff --git a/lib/parser.mly b/lib/parser.mly
index f49ac81a..0d816f5b 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -42,7 +42,7 @@
 %token <int> CYLSTACK
 %token <string> IDENT
 %token <string> INT
-%token CHECK EQUAL LET IN SET INV UNIT DECLARE
+%token CHECK EQUAL LET IN SET INV UNIT DECLARE BENCHMARK
 %token EOF
 
 %start prog
@@ -77,6 +77,8 @@ cmd:
   | SET IDENT EQUAL IDENT { Set ($2,$4) }
   | SET IDENT EQUAL INT { Set ($2,$4) }
   | DECLARE IDENT EQUAL builtin { Decl_builtin (Var.make_var $2,$4) }
+  | BENCHMARK args_or_ps EQUAL tmexpr { Benchmark ($2,$4) }
+  | BENCHMARK builtin { Benchmark_builtin ($2) }
 
 args_of_same_ty :
   | IDENT COL tyexpr { [Var.make_var $1, $3], $3 }
diff --git a/lib/printing.ml b/lib/printing.ml
index f46903fb..ff436864 100644
--- a/lib/printing.ml
+++ b/lib/printing.ml
@@ -10,11 +10,17 @@ struct
   open Unchecked_types (CohT) (TmT)
 
   module Make (Coh : sig
-    val to_string : CohT.t -> string
+    val to_string : ?unroll:bool -> CohT.t -> string
     val func_data : CohT.t -> (Var.t * int) list list
+    val forget : CohT.t -> ps * ty * pp_data
+    val is_equal : CohT.t -> CohT.t -> bool
   end) (Tm : sig
     val func_data : TmT.t -> (Var.t * int) list list option
     val name : TmT.t -> string option
+    val full_name : TmT.t -> string option
+    val develop : TmT.t -> tm
+    val ctx : TmT.t -> ctx
+    val is_equal : TmT.t -> TmT.t -> bool
   end) =
   struct
     module Regular = struct
@@ -184,6 +190,197 @@ struct
       let full_name name = pp_data_to_string ~print_func:true name
     end
 
+    module Kolmogorov = struct
+      type value = Tm of TmT.t | Coh of CohT.t
+
+      let counter = ref 0
+
+      let new_name () =
+        incr counter;
+        Printf.sprintf "tm_%i" !counter
+
+      let find t decls =
+        let rec find t decls =
+          match (t, decls) with
+          | _, [] -> None
+          | Tm t, (Tm u, n) :: _ when Tm.is_equal t u -> Some n
+          | Coh c1, (Coh c2, n) :: _ when Coh.is_equal c1 c2 -> Some n
+          | _, _ :: decls -> find t decls
+        in
+        find t decls
+
+      let rec collect_decls_ty decls = function
+        | Meta_ty _ -> assert false
+        | Obj -> decls
+        | Arr (_, u, v) ->
+            let decls = collect_decls_tm decls u in
+            collect_decls_tm decls v
+
+      and collect_decls_tm decls = function
+        | Var _ -> decls
+        | Meta_tm _ -> assert false
+        | Coh (c, s) ->
+            let decls =
+              match find (Coh c) decls with
+              | Some _ -> decls
+              | None ->
+                  let _, _, pp_data = Coh.forget c in
+                  let name = Regular.full_name pp_data in
+                  let decls = (Coh c, name) :: decls in
+                  collect_decls_coh decls c
+            in
+            collect_decls_sub_ps decls s
+        | App (t, s) ->
+            let decls =
+              match find (Tm t) decls with
+              | Some _ -> decls
+              | None ->
+                  let name =
+                    match Tm.full_name t with
+                    | Some name -> name
+                    | None -> new_name ()
+                  in
+                  let decls = (Tm t, name) :: decls in
+                  collect_decls_checkedtm decls t
+            in
+            collect_decls_sub decls s
+
+      and collect_decls_checkedtm decls t =
+        let decls = collect_decls_tm decls (Tm.develop t) in
+        collect_decls_ctx decls (Tm.ctx t)
+
+      and collect_decls_coh decls c =
+        let _, ty, _ = Coh.forget c in
+        collect_decls_ty decls ty
+
+      and collect_decls_sub_ps decls = function
+        | [] -> decls
+        | (t, expl) :: s ->
+            if expl then
+              let decls = collect_decls_tm decls t in
+              collect_decls_sub_ps decls s
+            else collect_decls_sub_ps decls s
+
+      and collect_decls_sub decls s =
+        collect_decls_sub_ps decls (List.map snd s)
+
+      and collect_decls_ctx decls = function
+        | [] -> decls
+        | (_, (ty, _)) :: ctx ->
+            collect_decls_ctx (collect_decls_ty decls ty) ctx
+
+      let order_decls decls =
+        let all_deps_done t ordered =
+          let deps =
+            match t with
+            | Tm t -> collect_decls_checkedtm [] t
+            | Coh c -> collect_decls_coh [] c
+          in
+          List.for_all
+            (fun (m, _) ->
+              List.exists
+                (fun (n, _) ->
+                  match (n, m) with
+                  | Tm t1, Tm t2 -> Tm.is_equal t1 t2
+                  | Coh c1, Coh c2 -> Coh.is_equal c1 c2
+                  | _, _ -> false)
+                ordered)
+            deps
+        in
+        let rec add_next decls ordered front =
+          match decls with
+          | [] -> assert false
+          | (t, n) :: decls when all_deps_done t ordered ->
+              (List.append front decls, (t, n) :: ordered)
+          | (t, n) :: decls -> add_next decls ordered ((t, n) :: front)
+        in
+        let rec add_recursively decls ordered =
+          match decls with
+          | [] -> ordered
+          | _ ->
+              let decls, ordered = add_next decls ordered [] in
+              add_recursively decls ordered
+        in
+        add_recursively decls []
+
+      let rec ty_to_string decls = function
+        | Meta_ty _ -> assert false
+        | Obj -> "*"
+        | Arr (_, u, v) ->
+            let u = tm_to_string decls u in
+            let v = tm_to_string decls v in
+            Printf.sprintf "%s -> %s" u v
+
+      and tm_to_string decls t =
+        match t with
+        | Var v -> Var.to_string v
+        | Meta_tm _ -> assert false
+        | Coh (c, s) ->
+            let c =
+              match find (Coh c) decls with Some c -> c | None -> assert false
+            in
+            let s = sub_ps_to_string decls s in
+            Printf.sprintf "%s %s" c s
+        | App (t, s) ->
+            let t =
+              match find (Tm t) decls with Some t -> t | None -> assert false
+            in
+            let s = sub_to_string decls s in
+            Printf.sprintf "%s %s" t s
+
+      and sub_ps_to_string decls s =
+        match s with
+        | [] -> ""
+        | (t, expl) :: s ->
+            if expl then
+              let t = tm_to_string decls t in
+              let s = sub_ps_to_string decls s in
+              Printf.sprintf "%s (%s)" s t
+            else sub_ps_to_string decls s
+
+      and sub_to_string decls s = sub_ps_to_string decls (List.map snd s)
+
+      let print_tm_in_ctx decls ctx tm =
+        let rec print decls ctx res =
+          match ctx with
+          | [] -> "λ" ^ res
+          | (x, (ty, true)) :: ctx ->
+              let ty = ty_to_string decls ty in
+              let res = Printf.sprintf "(%s,%s) %s" (Var.to_string x) ty res in
+              print decls ctx res
+          | (x, (ty, false)) :: ctx ->
+              let ty = ty_to_string decls ty in
+              let res = Printf.sprintf "{%s,%s} %s" (Var.to_string x) ty res in
+              print decls ctx res
+        in
+        print decls ctx (Printf.sprintf "=> %s" tm)
+
+      let print_tm t =
+        let rec print_decls decls res =
+          match decls with
+          | [] -> res
+          | (Tm t, name) :: decls ->
+              let ctx = Tm.ctx t in
+              let newtm = tm_to_string decls (Tm.develop t) in
+              let newdecl = print_tm_in_ctx decls ctx newtm in
+              let res =
+                Printf.sprintf "let %s = %s in \n %s" name newdecl res
+              in
+              print_decls decls res
+          | (Coh c, name) :: decls ->
+              let ps, ty, _ = Coh.forget c in
+              let res =
+                Printf.sprintf "let %s = Coh(%s, %s) in\n %s" name
+                  (Regular.ps_to_string ps) (ty_to_string decls ty) res
+              in
+              print_decls decls res
+        in
+        let decls = collect_decls_tm [] t in
+        let decls = order_decls decls in
+        let res = tm_to_string decls t in
+        print_decls decls res
+    end
+
     let ps_to_string = Regular.ps_to_string
     let ty_to_string = Regular.ty_to_string
     let tm_to_string = Regular.tm_to_string
@@ -194,5 +391,6 @@ struct
     let meta_ctx_to_string = Regular.meta_ctx_to_string
     let pp_data_to_string = Regular.pp_data_to_string
     let full_name = Regular.full_name
+    let print_kolmogorov = Kolmogorov.print_tm
   end
 end
diff --git a/lib/printing.mli b/lib/printing.mli
new file mode 100644
index 00000000..4956337a
--- /dev/null
+++ b/lib/printing.mli
@@ -0,0 +1,36 @@
+open Common
+open Unchecked_types
+
+module Printing (Coh : sig
+  type t
+end) (Tm : sig
+  type t
+end) : sig
+  open Unchecked_types(Coh)(Tm)
+
+  module Make (_ : sig
+    val to_string : ?unroll:bool -> Coh.t -> string
+    val func_data : Coh.t -> (Var.t * int) list list
+    val forget : Coh.t -> ps * ty * pp_data
+    val is_equal : Coh.t -> Coh.t -> bool
+  end) (_ : sig
+    val func_data : Tm.t -> (Var.t * int) list list option
+    val name : Tm.t -> string option
+    val full_name : Tm.t -> string option
+    val develop : Tm.t -> tm
+    val ctx : Tm.t -> ctx
+    val is_equal : Tm.t -> Tm.t -> bool
+  end) : sig
+    val ps_to_string : ps -> string
+    val ty_to_string : ty -> string
+    val tm_to_string : tm -> string
+    val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
+    val ctx_to_string : ctx -> string
+    val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
+    val sub_to_string_debug : sub -> string
+    val meta_ctx_to_string : meta_ctx -> string
+    val full_name : pp_data -> string
+    val pp_data_to_string : ?print_func:bool -> pp_data -> string
+    val print_kolmogorov : tm -> string
+  end
+end
diff --git a/test.t/features/benchmark.catt b/test.t/features/benchmark.catt
new file mode 100644
index 00000000..d18e2f8a
--- /dev/null
+++ b/test.t/features/benchmark.catt
@@ -0,0 +1,3 @@
+benchmark conecomp(2,1,2)
+benchmark conecomp(3,1,3)
+benchmark conecomp(3,2,3)

From 11aa0ab232cba85c1e2e5ca3f9ecadf49a007c16 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 30 Sep 2025 19:09:20 +0200
Subject: [PATCH 11/30] [printing] add test file

---
 test.t/coverage/benchmark.catt |   1 +
 test.t/run.t                   | 182 ++++++++++++++++++++++++++++++++-
 2 files changed, 180 insertions(+), 3 deletions(-)
 create mode 100644 test.t/coverage/benchmark.catt

diff --git a/test.t/coverage/benchmark.catt b/test.t/coverage/benchmark.catt
new file mode 100644
index 00000000..bcff9638
--- /dev/null
+++ b/test.t/coverage/benchmark.catt
@@ -0,0 +1 @@
+benchmark eh(4,2,1)
diff --git a/test.t/run.t b/test.t/run.t
index f605911b..b9c755d2 100644
--- a/test.t/run.t
+++ b/test.t/run.t
@@ -705,7 +705,7 @@
   [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.26,1) (.22,1) (.18,1) (.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .18)] .23) (!1builtin_comp3 (intch_src_op{3} .3 .17 .23) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .23) (builtin_comp2_op{2} .3 [.25]) (assoc_op{3} .3 .11 .21) (builtin_comp2_op{2} [.13] .21) (builtin_assc_op{3} .10 .8 .21))) (intch_tgt_op{3} .10 .8 .21))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .23) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .23) (builtin_comp2_op{2} .2 [.24]) (assoc_op{3} .2 .11 .20) (builtin_comp2_op{2} [.12] .20) (builtin_assc_op{3} .10 .7 .20))) (intch_tgt_op{3} .10 .7 .20)) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .22)])).
   [=^.^=] check cylcomp(3,2,3)
   [=D.D=] substitution: (.0, .0) (.1, .6) (.2, (builtin_comp2 .2 .11)) (.3, (builtin_comp2 .3 .11)) (.4, (builtin_comp2 [.4] .11)) (.5, (builtin_comp2 .10 .7)) (.6, (builtin_comp2 .10 .8)) (.7, (builtin_comp2 .10 [.9])) (.8, .12) (.9, .13) (.10, .14) (.11, (builtin_comp2 .15 .11)) (.12, (builtin_comp2 [.16] .11)) (.13, (builtin_comp2 .10 .17)) (.14, (builtin_comp2 .10 [.18])) (.15, .19) (.16, .20)
-  
+
   [=I.I=] valid term builtin_conecomp(3,2,3) of type (!1builtin_comp2 (builtin_comp2 [(!1builtin_comp2 .4 .16)] .11) .19) -> (!1builtin_comp2 .12 (builtin_comp2_func[(.4,1)]_op{1} (!1builtin_comp2 .9 .18) .10)).
   [=^.^=] check cylcomp(3,1,2)
   [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .16)] .19) (!1builtin_comp3 (intch_src_op{3} .3 .16 .19) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .16 .19) (builtin_comp2_op{2} .3 [.20]) (assoc_op{3} .3 .11 .18) (builtin_comp2_op{2} [.13] .18) (builtin_assc_op{3} .10 .8 .18))) (intch_tgt_op{3} .10 .8 .18))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .19) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .19) (builtin_comp2_op{2} .2 [.20]) (assoc_op{3} .2 .11 .18) (builtin_comp2_op{2} [.12] .18) (builtin_assc_op{3} .10 .7 .18))) (intch_tgt_op{3} .10 .7 .18)) (builtin_comp2_op{2} .10 [(builtin_comp2_op{2} [.9] .18)])).
@@ -717,9 +717,9 @@
   [=I.I=] valid term builtin_conecomp(3,2,3)_func[(.32,1) (.28,1) (.24,1) (.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (!1builtin_comp2 [.6] [.24]) .15)] .29) (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .5 .23 .15)] .29) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.23] .15) .29) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.23] .15) .29) (!1builtin_comp2 (builtin_comp2_op{2} [.5] .15) [.31]) (!1assoc (builtin_comp2_op{2} [.5] .15) .17 (builtin_comp2_op{2} .14 [.27])) (!1builtin_comp2 [.19] (builtin_comp2_op{2} .14 [.27])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.27])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.27]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .12 .27)]))) -> (!2builtin_comp2 (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .4 .22 .15)] .29) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .29) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .29) (!1builtin_comp2 (builtin_comp2_op{2} [.4] .15) [.30]) (!1assoc (builtin_comp2_op{2} [.4] .15) .17 (builtin_comp2_op{2} .14 [.26])) (!1builtin_comp2 [.18] (builtin_comp2_op{2} .14 [.26])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.26])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.26]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .11 .26)])) (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (!1builtin_comp2 [.13] [.28]))])).
   [=^.^=] check cylcomp(4,3,4)
   [=D.D=] substitution: (.0, .0) (.1, .6) (.2, (builtin_comp2 .2 .11)) (.3, (builtin_comp2 .3 .11)) (.4, (builtin_comp2 [.4] .11)) (.5, (builtin_comp2 .10 .7)) (.6, (builtin_comp2 .10 .8)) (.7, (builtin_comp2 .10 [.9])) (.8, .12) (.9, .13) (.10, .14) (.11, (builtin_comp2 .15 .11)) (.12, (builtin_comp2 [.16] .11)) (.13, (builtin_comp2 .10 .17)) (.14, (builtin_comp2 .10 [.18])) (.15, .19) (.16, .20)
-  
+
   [=D.D=] substitution: (.0, .0) (.1, .8) (.2, (builtin_comp2 .2 .15)) (.3, (builtin_comp2 .3 .15)) (.4, (builtin_comp2 [.4] .15)) (.5, (builtin_comp2 [.5] .15)) (.6, (builtin_comp2 [[.6]] .15)) (.7, (builtin_comp2 .14 .9)) (.8, (builtin_comp2 .14 .10)) (.9, (builtin_comp2 .14 [.11])) (.10, (builtin_comp2 .14 [.12])) (.11, (builtin_comp2 .14 [[.13]])) (.12, .16) (.13, .17) (.14, .18) (.15, .19) (.16, .20) (.17, (builtin_comp2 [.21] .15)) (.18, (builtin_comp2 [[.22]] .15)) (.19, (builtin_comp2 .14 [.23])) (.20, (builtin_comp2 .14 [[.24]])) (.21, .25) (.22, .26)
-  
+
   [=I.I=] valid term builtin_conecomp(4,3,4) of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2 [[(!2builtin_comp2 .6 .22)]] .15)] .17) .25) -> (!2builtin_comp2 .18 (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,2)]_op{1} (!2builtin_comp2 .13 .24) .14)])).
   [=^.^=] check cylcomp(4,1,2)
   [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.14,1) (.9,1) (.4,1)]_op{3}_func[(.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .6 .22) .25)] (!1builtin_comp3 (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 [(intch_src_func[(.4,1)]_op{3} .5 .22 .25)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1)]_op{3} .5 .22 .25) (builtin_comp2_func[(.8,1)][(.4,1)]_op{3} .5 .26) (assoc_func[(.4,1)]_op{3} .5 .15 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .19 .24) (builtin_assc_func[(.6,1)]_op{3} .14 .12 .24)))] (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) [(intch_tgt_func[(.6,1)]_op{3} .14 .12 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 [(intch_src_func[(.4,1)]_op{3} .4 .22 .25)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1)]_op{3} .4 .22 .25) (builtin_comp2_func[(.8,1)][(.4,1)]_op{3} .4 .26) (assoc_func[(.4,1)]_op{3} .4 .15 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .18 .24) (builtin_assc_func[(.6,1)]_op{3} .14 .11 .24)))] (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)])) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) [(intch_tgt_func[(.6,1)]_op{3} .14 .11 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .13 .24))])).
@@ -771,3 +771,179 @@
   [=I.I=] valid term (!3builtin_comp2 (eh^3_(1,2) .1 .2) (I(eh^3_(1,2)_op{3}) .2 .1)) of type (!1builtin_comp2 [.1] [.2]) -> (!1builtin_comp2_func[(.6,1) (.10,1)]_op{3} .2 .1).
   [=^.^=] check EH^3_(2,0)
   [=I.I=] valid term (!3builtin_comp2 (eh^3_(2,0) .1 .2) (I(eh^3_(2,0)_op{1}) .2 .1)) of type (!2builtin_comp2 .1 .2) -> (!2builtin_comp2 .2 .1).
+
+  $ catt coverage/benchmark.catt
+  [=I.I=] term computes to:
+   let !4builtin_comp9 = Coh([[[[[[][][][][][][][][]]]]]], .8 -> .25) in
+   let !4builtin_comp11 = Coh([[[[[[][][][][][][][][][][]]]]]], .8 -> .29) in
+   let !4builtin_comp7 = Coh([[[[[[][][][][][][]]]]]], .8 -> .21) in
+   let !4builtin_comp5 = Coh([[[[[[][][][][]]]]]], .8 -> .17) in
+   let !3builtin_comp5_red = Coh([[[[[]]]]], .6 -> .7) in
+   let !3builtin_comp5_red_func[(.10,1)]_op{5} = Coh([[[[[[]]]]]], !3builtin_comp5_red  (.8) -> !3builtin_comp5_red  (.9)) in
+   let !4builtin_comp3 = Coh([[[[[[][][]]]]]], .8 -> .13) in
+   let !1BPad.Padding(1)_func[(.6,1)] = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) => .6 in 
+   let !1BPad.Padding(1)_func[(.4,1)]_op{1} = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) => .6 in 
+   let !1BPad.Padding(1) = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) (.4,.2 -> .3) => .4 in 
+   let !1BPad.Padding(1)_op{1} = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) (.4,.3 -> .2) => .4 in 
+   let !1UBPad.Padding(1)_func[(.5,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.2 -> .2} {.4,.2 -> .2} (.5,.3 -> .4) => .5 in 
+   let !3builtin_id = Coh([[[[]]]], .6 -> .6) in
+   let !3builtin_comp4 = Coh([[[[[][][][]]]]], .6 -> .13) in
+   let !3builtin_comp4_func[(.16,1)] = Coh([[[[[][][][[]]]]]], !3builtin_comp4  (.8) (.10) (.12) (.14) -> !3builtin_comp4  (.8) (.10) (.12) (.15)) in
+   let !3builtin_comp4_func[(.14,1)] = Coh([[[[[][][[]][]]]]], !3builtin_comp4  (.8) (.10) (.12) (.16) -> !3builtin_comp4  (.8) (.10) (.13) (.16)) in
+   let !3builtin_comp4_func[(.12,1)] = Coh([[[[[][[]][][]]]]], !3builtin_comp4  (.8) (.10) (.14) (.16) -> !3builtin_comp4  (.8) (.11) (.14) (.16)) in
+   let !3builtin_comp4_func[(.10,1)] = Coh([[[[[[]][][][]]]]], !3builtin_comp4  (.8) (.12) (.14) (.16) -> !3builtin_comp4  (.9) (.12) (.14) (.16)) in
+   let !1UBPad.Padding(1) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,.2 -> .2) => .3 in 
+   let !3builtin_comp5 = Coh([[[[[][][][][]]]]], .6 -> .15) in
+   let !3builtin_comp5_func[(.10,1)] = Coh([[[[[[]][][][][]]]]], !3builtin_comp5  (.8) (.12) (.14) (.16) (.18) -> !3builtin_comp5  (.9) (.12) (.14) (.16) (.18)) in
+   let !3builtin_comp5_func[(.12,1)] = Coh([[[[[][[]][][][]]]]], !3builtin_comp5  (.8) (.10) (.14) (.16) (.18) -> !3builtin_comp5  (.8) (.11) (.14) (.16) (.18)) in
+   let !3builtin_comp5_func[(.14,1)] = Coh([[[[[][][[]][][]]]]], !3builtin_comp5  (.8) (.10) (.12) (.16) (.18) -> !3builtin_comp5  (.8) (.10) (.13) (.16) (.18)) in
+   let !3builtin_comp5_func[(.16,1)] = Coh([[[[[][][][[]][]]]]], !3builtin_comp5  (.8) (.10) (.12) (.14) (.18) -> !3builtin_comp5  (.8) (.10) (.12) (.15) (.18)) in
+   let !3builtin_comp5_func[(.18,1)] = Coh([[[[[][][][][[]]]]]], !3builtin_comp5  (.8) (.10) (.12) (.14) (.16) -> !3builtin_comp5  (.8) (.10) (.12) (.14) (.17)) in
+   let !2builtin_comp3_red = Coh([[[[]]]], .4 -> .5) in
+   let !2builtin_comp3_red_func[(.8,1)] = Coh([[[[[]]]]], !2builtin_comp3_red  (.6) -> !2builtin_comp3_red  (.7)) in
+   let !2builtin_comp3_red_func[(.8,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) => !2builtin_comp3_red_func[(.8,1)]  (.8) in 
+   let !2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5} = Coh([[[[[[]]]]]], !2builtin_comp3_red_func[(.8,1)]  (.8) -> !2builtin_comp3_red_func[(.8,1)]  (.9)) in
+   let !3builtin_comp2 = Coh([[[[[][]]]]], .6 -> .9) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16)) (.18) -> !3builtin_comp5  (.8) (.10) (.12) (.14) (!3builtin_comp2  (.16) (.18))) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16) (.18) -> !3builtin_comp5  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16) (.18)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp5  (.10) (.12) (.14) (.16) (.18)) -> !3builtin_comp5  (!3builtin_comp2  (.8) (.10)) (.12) (.14) (.16) (.18)) in
+   let intch_tgt^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp5  (.10) (.12) (.14) (.16) (.18)) -> !3builtin_comp5_red  (!3builtin_comp2  (.8) (!3builtin_comp5  (.10) (.12) (.14) (.16) (.18)))) in
+   let intch_tgt^-1 = Coh([[[[[][]]]]], !3builtin_comp2  (!2builtin_comp3_red_func[(.8,1)]  (.8)) (!2builtin_comp3_red_func[(.8,1)]  (.10)) -> !2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp2  (.8) (.10))) in
+   let !3builtin_assc = Coh([[[[[][][]]]]], !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12) -> !3builtin_comp2  (.8) (!3builtin_comp2  (.10) (.12))) in
+   let intch_src^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp4  (.8) (.10) (.12) (.14)) (.16)) -> !3builtin_comp2  (!3builtin_comp4  (.8) (.10) (.12) (.14)) (.16)) in
+   let !3_ehnat_step1 = Coh([[[[[]]]]], .8 -> !3builtin_comp2  (.8) (!3builtin_id  (.7))) in
+   let intch_tgt^-1 = Coh([[[[[][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp2  (.10) (.12)) -> !3builtin_comp5_red  (!3builtin_comp2  (.8) (!3builtin_comp2  (.10) (.12)))) in
+   let intch_tgt^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp4  (.10) (.12) (.14) (.16)) -> !3builtin_comp5_red  (!3builtin_comp2  (.8) (!3builtin_comp4  (.10) (.12) (.14) (.16)))) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp4  (.10) (.12) (.14) (.16)) -> !3builtin_comp4  (!3builtin_comp2  (.8) (.10)) (.12) (.14) (.16)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16) -> !3builtin_comp4  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16)) -> !3builtin_comp2  (!3builtin_comp4  (.8) (.10) (.12) (.14)) (.16)) in
+   let intch_src^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp5  (.8) (.10) (.12) (.14) (.16)) (.18)) -> !3builtin_comp2  (!3builtin_comp5  (.8) (.10) (.12) (.14) (.16)) (.18)) in
+   let !3builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.4 -> .5} (.10,.7 -> .9) => !3builtin_comp2  (.8) (.10) in 
+   let !3builtin_id^-1_func[(.8,1)] = Coh([[[[[]]]]], !3builtin_comp2  (.8) (!3builtin_id  (.7)) -> !3builtin_comp2  (!3builtin_id  (.6)) (.8)) in
+   let !3builtin_comp2_func[(.10,1)] = Coh([[[[[[]][]]]]], !3builtin_comp2  (.8) (.12) -> !3builtin_comp2  (.9) (.12)) in
+   let !3builtin_comp2_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} {.8,.6 -> .7} {.9,.6 -> .7} (.10,.8 -> .9) {.11,.4 -> .5} (.12,.7 -> .11) => !3builtin_comp2_func[(.10,1)]  (.10) (.12) in 
+   let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16) -> !3builtin_comp4  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16))) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (!3builtin_comp2  (.8) (.10)) (.12) (.14) (.16) -> !3builtin_comp4  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (!3builtin_comp2  (.8) (.10)) (.12) (.14) (.16) (.18) -> !3builtin_comp5  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16) (.18)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16) (.18) -> !3builtin_comp5  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16)) (.18)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (.10) (.12) (.14) (!3builtin_comp2  (.16) (.18)) -> !3builtin_comp2  (!3builtin_comp5  (.8) (.10) (.12) (.14) (.16)) (.18)) in
+   let !3builtin_comp2_func[(.12,1)] = Coh([[[[[][[]]]]]], !3builtin_comp2  (.8) (.10) -> !3builtin_comp2  (.8) (.11)) in
+   let !3builtin_comp2_func[(.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.4 -> .5} {.10,.7 -> .9} {.11,.7 -> .9} (.12,.10 -> .11) => !3builtin_comp2_func[(.12,1)]  (.8) (.12) in 
+   let !3assoc = Coh([[[[[][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp2  (.10) (.12)) -> !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12)) in
+   let intch_src^-1 = Coh([[[[[][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12)) -> !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12)) in
+   let intch_src^-1 = Coh([[[[[][]]]]], !2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp2  (.8) (.10)) -> !3builtin_comp2  (!2builtin_comp3_red_func[(.8,1)]  (.8)) (!2builtin_comp3_red_func[(.8,1)]  (.10))) in
+   let !2builtin_comp2 = Coh([[[[][]]]], .4 -> .7) in
+   let !2builtin_comp2_func[(.8,1)] = Coh([[[[[]][]]]], !2builtin_comp2  (.6) (.10) -> !2builtin_comp2  (.7) (.10)) in
+   let !2builtin_comp2_func[(.8,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} (.10,.5 -> .9) => !2builtin_comp2_func[(.8,1)]  (.8) (.10) in 
+   let !1!1builtin_comp2_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) {.7,.3 -> .2} (.8,.5 -> .7) => !2builtin_comp2  (.6) (.8) in 
+   let !2builtin_comp2_func[(.8,1) (.12,1)] = Coh([[[[[]][[]]]]], !2builtin_comp2  (.6) (.10) -> !2builtin_comp2  (.7) (.11)) in
+   let !2builtin_comp2_func[(.8,1) (.12,1)]_red_func[(.10,1) (.16,1)]_op{5} = Coh([[[[[[]]][[[]]]]]], !2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.14) -> !2builtin_comp2_func[(.8,1) (.12,1)]  (.9) (.15)) in
+   let !2builtin_comp2_func[(.8,1) (.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} {.10,.5 -> .9} {.11,.5 -> .9} (.12,.10 -> .11) => !2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.12) in 
+   let intch_src^-1 = Coh([[[[[][]][[][]]]]], !2builtin_comp2_func[(.8,1) (.12,1)]  (!3builtin_comp2  (.8) (.10)) (!3builtin_comp2  (.14) (.16)) -> !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.14)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (.10) (.16))) in
+   let intch_tgt^-1 = Coh([[[[[][]][[][]]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.14)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (.10) (.16)) -> !2builtin_comp2_func[(.8,1) (.12,1)]  (!3builtin_comp2  (.8) (.10)) (!3builtin_comp2  (.14) (.16))) in
+   let !2builtin_comp2_func[(.10,1)] = Coh([[[[][[]]]]], !2builtin_comp2  (.6) (.8) -> !2builtin_comp2  (.6) (.9)) in
+   let !2builtin_comp2_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} {.8,.5 -> .7} {.9,.5 -> .7} (.10,.8 -> .9) => !2builtin_comp2_func[(.10,1)]  (.6) (.10) in 
+   let !2builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} (.8,.5 -> .7) => !2builtin_comp2  (.6) (.8) in 
+   let !2builtin_id = Coh([[[]]], .4 -> .4) in
+   let !1BToURepad.Repadding(1) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,.2 -> .2) => !2builtin_id  (.3) in 
+   let !2builtin_id^-1_func[(.6,1)] = Coh([[[[]]]], !2builtin_comp2  (.6) (!2builtin_id  (.5)) -> !2builtin_comp2  (!2builtin_id  (.4)) (.6)) in
+   let !2builtin_id^-1^-1_func[(.8,2)] = Coh([[[[[]]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1)]  (.8) (!2builtin_id  (.5))) (!2builtin_id^-1_func[(.6,1)]  (.7)) -> !3builtin_comp2  (!2builtin_id^-1_func[(.6,1)]  (.6)) (!2builtin_comp2_func[(.10,1)]  (!2builtin_id  (.4)) (.8))) in
+   let !1builtin_id = Coh([[]], .2 -> .2) in
+   let !1builtin_comp2 = Coh([[[][]]], .2 -> .5) in
+   let !1builtin_comp2_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) {.5,.0 -> .1} (.6,.5 -> .3) => !1builtin_comp2  (.6) (.4) in 
+   let !1BPad.p(1)_op{1} = Coh([[[]]], !1BPad.Padding(1)_op{1}  (.3) (.2) (!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.2))) -> .4) in
+   let tm_6 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)_op{1}  (.5) in 
+   let !1BPad.p(1)_op{1} = Coh([[[]]], .4 -> !1BPad.Padding(1)_op{1}  (.3) (.2) (!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.2)))) in
+   let tm_5 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)_op{1}  (.4) in 
+   let !1builtin_comp2_func[(.6,1) (.10,1)] = Coh([[[[]][[]]]], !1builtin_comp2  (.4) (.8) -> !1builtin_comp2  (.5) (.9)) in
+   let !1builtin_comp2_func[(.8,2) (.14,2)] = Coh([[[[[]]][[[]]]]], !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.12) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.7) (.13)) in
+   let !1builtin_comp2_func[(.8,2) (.14,2)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.0 -> .1} {.10,.3 -> .9} {.11,.3 -> .9} {.12,.10 -> .11} {.13,.10 -> .11} (.14,.12 -> .13) => !1builtin_comp2_func[(.8,2) (.14,2)]  (.8) (.14) in 
+   let !1builtin_comp2_func[(.6,1) (.12,2)] = Coh([[[[]][[[]]]]], !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.11)) in
+   let !1builtin_comp2_func[(.6,1) (.12,2)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.3 -> .7} {.9,.3 -> .7} {.10,.8 -> .9} {.11,.8 -> .9} (.12,.10 -> .11) => !1builtin_comp2_func[(.6,1) (.12,2)]  (.6) (.12) in 
+   let !1builtin_comp2_func[(.8,2) (.12,1)] = Coh([[[[[]]][[]]]], !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.12) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.7) (.12)) in
+   let !1builtin_comp2_func[(.8,2) (.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.0 -> .1} {.10,.3 -> .9} {.11,.3 -> .9} (.12,.10 -> .11) => !1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (.12) in 
+   let !1builtin_comp2_func[(.4,1) (.8,1)]_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.7 -> .3} {.9,.7 -> .3} (.10,.8 -> .9) => !1builtin_comp2_func[(.6,1) (.10,1)]  (.10) (.6) in 
+   let !1builtin_comp2_func[(.6,1) (.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.3 -> .7} {.9,.3 -> .7} (.10,.8 -> .9) => !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10) in 
+   let !1intch(2,0) = Coh([[[[]][[]]]], !2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (!2builtin_id  (.8))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (.5)) (.10)) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10)) in
+   let !1intch(2,0)^-1_func[(.8,1) (.14,1)] = Coh([[[[[]]][[[]]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (!2builtin_id  (.10))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (.5)) (.14))) (!1intch(2,0)  (.7) (.13)) -> !3builtin_comp2  (!1intch(2,0)  (.6) (.12)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.8) (.14))) in
+   let !1builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) {.5,.0 -> .1} (.6,.3 -> .5) => !1builtin_comp2  (.4) (.6) in 
+   let !1UBPad.p(1) = Coh([[]], !1builtin_id  (.2) -> !1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)))) in
+   let !1BPad.p(1) = Coh([[[]]], !1BPad.Padding(1)  (.2) (.3) (!1builtin_comp2  (.4) (!1builtin_id  (.3))) -> .4) in
+   let tm_8 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)  (.5) in 
+   let tm_4 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => .3 in 
+   let !1UBPad.p(1) = Coh([[]], !1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) -> !1builtin_id  (.2)) in
+   let tm_2 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !1UBPad.p(1)  (.2) in 
+   let !1UBPad.p(1)_Unit = Coh([[]], !2builtin_comp2  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)))) (!1builtin_id  (.2)) (!1UBPad.p(1)  (.2)) (!1UBPad.p(1)  (.2)) -> !2builtin_id  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))))) in
+   let !1BToURepad.g(1) = Coh([[]], !1BPad.p(1)  (!1builtin_id  (.2)) -> !2builtin_comp2  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) in
+   let !1BToURepad.f(1)_op{1} = Coh([[]], !1!1builtin_comp2_op{1}  (!1BPad.p(1)_op{1}  (!1builtin_id  (.2))) (!1BToURepad.Repadding(1) ) -> !1UBPad.p(1)  (.2)) in
+   let tm_1 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !1UBPad.p(1)  (.2) in 
+   let !1BPad.p(1) = Coh([[[]]], .4 -> !1BPad.Padding(1)  (.2) (.3) (!1builtin_comp2  (.4) (!1builtin_id  (.3)))) in
+   let tm_7 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)  (.4) in 
+   let !1BToURepad.f(1) = Coh([[]], !2builtin_comp2  (!1BPad.p(1)  (!1builtin_id  (.2))) (!1BToURepad.Repadding(1) ) -> !1UBPad.p(1)  (.2)) in
+   let !1BToURepad.g(1)_op{1} = Coh([[]], !1BPad.p(1)_op{1}  (!1builtin_id  (.2)) -> !1!1builtin_comp2_op{1}  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) in
+   let builtin_id = Coh([], .0 -> .0) in
+   let ΣUToURepad.Repadding(2) = λ{.0,*} (.1,builtin_id  (.0) -> builtin_id  (.0)) => !2builtin_id  (.1) in 
+   let UBPad.Padding(2)_func[(.3,1)] = λ{.0,*} {.1,builtin_id  (.0) -> builtin_id  (.0)} {.2,builtin_id  (.0) -> builtin_id  (.0)} (.3,.1 -> .2) => .3 in 
+   let UBPad.Padding(2) = λ{.0,*} (.1,builtin_id  (.0) -> builtin_id  (.0)) => .1 in 
+   let UBPad.p(2) = Coh([], !1builtin_id  (builtin_id  (.0)) -> UBPad.Padding(2)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))))) in
+   let ΣUToURepad.f(2) = Coh([], !2builtin_comp2  (!1UBPad.p(1)  (builtin_id  (.0))) (ΣUToURepad.Repadding(2) ) -> UBPad.p(2)  (.0)) in
+   let UBPad.p(2) = Coh([], UBPad.Padding(2)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) -> !1builtin_id  (builtin_id  (.0))) in
+   let ΣUToURepad.g(2) = Coh([], !1UBPad.p(1)  (builtin_id  (.0)) -> !2builtin_comp2  (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) in
+   let !2builtin_comp3 = Coh([[[[][][]]]], .4 -> .9) in
+   let !2builtin_comp3_func[(.8,1)] = Coh([[[[[]][][]]]], !2builtin_comp3  (.6) (.10) (.12) -> !2builtin_comp3  (.7) (.10) (.12)) in
+   let !1BPad.Padding(2) = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !2builtin_comp3  (!1BPad.p(1)  (.4)) (!1BPad.Padding(1)_func[(.6,1)]  (.2) (.3) (.6)) (!1BPad.p(1)  (.5)) in 
+   let !1BPad.p(2) = Coh([[[[]]]], .6 -> !1BPad.Padding(2)  (.4) (.5) (!1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (!2builtin_id  (!1builtin_id  (.3))))) in
+   let !2intch_src = Coh([[[[][][]]]], !2builtin_comp3  (.6) (.8) (.10) -> !2builtin_comp3_red  (!2builtin_comp3  (.6) (.8) (.10))) in
+   let !2_builtin_unitor = Coh([[[[][]]]], !2builtin_comp3  (.6) (!2builtin_id  (.5)) (.8) -> !2builtin_comp2  (.6) (.8)) in
+   let !1BPad.Padding(2)_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !2builtin_comp3  (!1BPad.p(1)_op{1}  (.4)) (!1BPad.Padding(1)_func[(.4,1)]_op{1}  (.2) (.3) (.6)) (!1BPad.p(1)_op{1}  (.5)) in 
+   let !1BPad.p(2)_op{1} = Coh([[[[]]]], .6 -> !1BPad.Padding(2)_op{1}  (.4) (.5) (!1builtin_comp2_func[(.4,1) (.8,1)]_op{1}  (.6) (!2builtin_id  (!1builtin_id  (.2))))) in
+   let !2_builtin_assoc = Coh([[[[][][][][][]]]], !2builtin_comp2  (!2builtin_comp3  (.6) (.8) (.10)) (!2builtin_comp3  (.12) (.14) (.16)) -> !2builtin_comp3  (.6) (!2builtin_comp3  (.8) (!2builtin_comp2  (.10) (.12)) (.14)) (.16)) in
+   let !2builtin_assc = Coh([[[[][][][]]]], !2builtin_comp3  (.6) (!2builtin_comp2  (.8) (.10)) (.12) -> !2builtin_comp3  (!2builtin_comp2  (.6) (.8)) (.10) (.12)) in
+   let !2builtin_assc = Coh([[[[][][][]]]], !2builtin_comp3  (.6) (.8) (!2builtin_comp2  (.10) (.12)) -> !2builtin_comp3  (.6) (!2builtin_comp2  (.8) (.10)) (.12)) in
+   let !2builtin_comp3_func[(.12,1)] = Coh([[[[][][[]]]]], !2builtin_comp3  (.6) (.8) (.10) -> !2builtin_comp3  (.6) (.8) (.11)) in
+   let !2builtin_comp3_func[(.10,1)] = Coh([[[[][[]][]]]], !2builtin_comp3  (.6) (.8) (.12) -> !2builtin_comp3  (.6) (.9) (.12)) in
+   let UBPad.Padding(3)_func[(.3,1)] = λ{.0,*} {.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))} {.2,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))} (.3,.1 -> .2) => !2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (.3) (UBPad.p(2)  (.0)) in 
+   let !1UBPad.Padding(2)_func[(.5,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))} {.4,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))} (.5,.3 -> .4) => !2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (.5) (!1UBPad.p(1)  (.2)) in 
+   let !2builtin_comp3_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} {.8,.5 -> .7} {.9,.5 -> .7} (.10,.8 -> .9) {.11,.2 -> .3} (.12,.7 -> .11) => !2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12) in 
+   let tm_3 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) (.4,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2)) (!1UBPad.p(1)  (.2)) (tm_4  (.4)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)_Unit  (.2)) (tm_4  (.4))) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_4  (.4))) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!3builtin_id  (!2builtin_comp2  (.3) (.4))) (!1UBPad.p(1)  (.2))) in 
+   let intch_tgt^-1 = Coh([[[[][[][]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14)) -> !2builtin_comp3_func[(.10,1)]  (.6) (!3builtin_comp2  (.10) (.12)) (.14)) in
+   let !2intch_src^-1_func[(.10,1)] = Coh([[[[][[]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)) (!2intch_src  (.6) (.9) (.12)) -> !3builtin_comp2  (!2intch_src  (.6) (.8) (.12)) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)))) in
+   let !1BPad.p(2)^-1_func[(.8,1)] = Coh([[[[[]]]]], !3builtin_comp2  (.8) (!1BPad.p(2)  (.7)) -> !3builtin_comp2  (!1BPad.p(2)  (.6)) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)  (.4)) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (!2builtin_id  (!1builtin_id  (.3)))) (!1BPad.p(1)  (.5)))) in
+   let !1BPad.p(2)_op{1}^-1_func[(.8,1)] = Coh([[[[[]]]]], !3builtin_comp2  (.8) (!1BPad.p(2)_op{1}  (.7)) -> !3builtin_comp2  (!1BPad.p(2)_op{1}  (.6)) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)_op{1}  (.4)) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (.2))) (.8)) (!1BPad.p(1)_op{1}  (.5)))) in
+   let !2builtin_assc^-1_func[(.12,1)] = Coh([[[[][][[]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (!2builtin_comp2_func[(.10,1)]  (.8) (.12)) (.14)) (!2builtin_assc  (.6) (.8) (.11) (.14)) -> !3builtin_comp2  (!2builtin_assc  (.6) (.8) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (.6) (.8)) (.12) (.14))) in
+   let !2builtin_comp3_func[(.8,1) (.14,1)] = Coh([[[[[]][][[]]]]], !2builtin_comp3  (.6) (.10) (.12) -> !2builtin_comp3  (.7) (.10) (.13)) in
+   let !2builtin_comp3_func[(.8,1) (.14,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} (.10,.5 -> .9) {.11,.2 -> .3} {.12,.9 -> .11} {.13,.9 -> .11} (.14,.12 -> .13) => !2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.10) (.14) in 
+   let !2_builtin_assoc^-1_func[(.10,1) (.18,1)] = Coh([[[[][[]][][][[]][]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)) (!2builtin_comp3_func[(.10,1)]  (.14) (.18) (.20))) (!2_builtin_assoc  (.6) (.9) (.12) (.14) (.17) (.20)) -> !3builtin_comp2  (!2_builtin_assoc  (.6) (.8) (.12) (.14) (.16) (.20)) (!2builtin_comp3_func[(.10,1)]  (.6) (!2builtin_comp3_func[(.8,1) (.14,1)]  (.10) (!2builtin_comp2  (.12) (.14)) (.18)) (.20))) in
+   let !2_builtin_unitor^-1_func[(.8,1) (.12,1)] = Coh([[[[[]][[]]]]], !3builtin_comp2  (!2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (!2builtin_id  (.5)) (.12)) (!2_builtin_unitor  (.7) (.11)) -> !3builtin_comp2  (!2_builtin_unitor  (.6) (.10)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.12))) in
+   let !2builtin_comp3^-1_func[(.12,1)][(.8,1) (.16,1)] = Coh([[[[[]][[]][[]]]]], !3builtin_comp2  (!2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.10) (.16)) (!2builtin_comp3_func[(.10,1)]  (.7) (.12) (.15)) -> !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14)) (!2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.11) (.16))) in
+   let !2builtin_assc^-1_func[(.10,1)] = Coh([[[[][[]][][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (!2builtin_comp2  (.12) (.14))) (!2builtin_assc  (.6) (.9) (.12) (.14)) -> !3builtin_comp2  (!2builtin_assc  (.6) (.8) (.12) (.14)) (!2builtin_comp3_func[(.10,1)]  (.6) (!2builtin_comp2_func[(.8,1)]  (.10) (.12)) (.14))) in
+   let !2builtin_comp3^-1_func[(.14,1)][(.10,1)] = Coh([[[[][[]][[]]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)) (!2builtin_comp3_func[(.12,1)]  (.6) (.9) (.14)) -> !3builtin_comp2  (!2builtin_comp3_func[(.12,1)]  (.6) (.8) (.14)) (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.13))) in
+   let !2builtin_comp3^-1_func[(.8,1)][(.12,1)] = Coh([[[[[]][[]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14)) (!2builtin_comp3_func[(.8,1)]  (.8) (.11) (.14)) -> !3builtin_comp2  (!2builtin_comp3_func[(.8,1)]  (.8) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (.7) (.12) (.14))) in
+   let !2intch_tgt = Coh([[[[][][]]]], !2builtin_comp3_red  (!2builtin_comp3  (.6) (.8) (.10)) -> !2builtin_comp3  (.6) (.8) (.10)) in
+   let !2intch_tgt^-1_func[(.10,1)] = Coh([[[[][[]][]]]], !3builtin_comp2  (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12))) (!2intch_tgt  (.6) (.9) (.12)) -> !3builtin_comp2  (!2intch_tgt  (.6) (.8) (.12)) (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12))) in
+   let intch_src^-1 = Coh([[[[][[][]][]]]], !2builtin_comp3_func[(.10,1)]  (.6) (!3builtin_comp2  (.10) (.12)) (.14) -> !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14))) in
+   let !2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5} = Coh([[[[][[[]]][]]]], !2builtin_comp3_func[(.10,1)]  (.6) (.10) (.14) -> !2builtin_comp3_func[(.10,1)]  (.6) (.11) (.14)) in
+   let UBPad.Padding(3) = λ{.0,*} (.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) => !2builtin_comp3  (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0)) in 
+   let UBPad.p(3) = Coh([], !2builtin_comp2  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) -> UBPad.Padding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) in
+   let UBPad.p(3) = Coh([], UBPad.Padding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) -> !2builtin_comp2  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) in
+   let !3builtin_comp3 = Coh([[[[[][][]]]]], .6 -> .11) in
+   let !1BToURepad.Repadding(2) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp3  (!2intch_src  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_8  (.3))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.g(1)  (.2))) (!2builtin_assc  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (.3)) (!2builtin_id^-1_func[(.6,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_assc  (tm_7  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))))) (!2intch_tgt  (!1builtin_id  (.2)) (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) in 
+   let intch_tgt^-1 = Coh([[[[[][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp3  (.10) (.12) (.14)) -> !3builtin_comp5_red  (!3builtin_comp2  (.8) (!3builtin_comp3  (.10) (.12) (.14)))) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp3  (.10) (.12) (.14)) -> !3builtin_comp3  (!3builtin_comp2  (.8) (.10)) (.12) (.14)) in
+   let !1BToURepad.Repadding(2)_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2_op{1}  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2_op{1}  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp3  (!2intch_src  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_6  (.3))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.g(1)_op{1}  (.2))) (!2builtin_assc  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (.3)) (!2builtin_id^-1_func[(.6,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_assc  (tm_5  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))))) (!2intch_tgt  (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) in 
+   let !1eh^2_(1,0) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_id  (.2) -> !1builtin_id  (.2)) (.4,!1builtin_id  (.2) -> !1builtin_id  (.2)) => !3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (.3)) (!1BPad.p(2)_op{1}  (.4))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.3) (!2builtin_id  (!1builtin_id  (.2))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (.2))) (.4)))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.3) (!2builtin_id  (!1builtin_id  (.2)))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (.2))) (.4))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (.3) (.4))) in 
+   let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp3  (!3builtin_comp2  (.8) (.10)) (.12) (.14) -> !3builtin_comp3  (.8) (!3builtin_comp2  (.10) (.12)) (.14)) in
+   let !3builtin_comp3_func[(.12,1)] = Coh([[[[[][[]][]]]]], !3builtin_comp3  (.8) (.10) (.14) -> !3builtin_comp3  (.8) (.11) (.14)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp3  (.8) (!3builtin_comp2  (.10) (.12)) (.14) -> !3builtin_comp3  (.8) (.10) (!3builtin_comp2  (.12) (.14))) in
+   let ΣUToURepad.Repadding(3) = λ{.0,*} (.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) => !3builtin_comp3  (!2intch_src  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (tm_2  (.1))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (.1)) (!2builtin_id^-1_func[(.6,1)]  (.1)) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (.1)) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))) in 
+   let eh^3_(2,1) = λ{.0,*} (.1,!1builtin_id  (builtin_id  (.0)) -> !1builtin_id  (builtin_id  (.0))) (.2,!1builtin_id  (builtin_id  (.0)) -> !1builtin_id  (builtin_id  (.0))) => !3builtin_comp2  (!1eh^2_(1,0)  (.1) (.2)) (ΣUToURepad.Repadding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.1) (.2))) in 
+   let _eh_to_p(3,2,1) = Coh([], eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) -> UBPad.p(3)  (.0)) in
+   let !3_unbiasor_left = Coh([[[[[][][]]]]], !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12) -> !3builtin_comp3  (.8) (.10) (.12)) in
+   let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp3  (.8) (.10) (!3builtin_comp2  (.12) (.14)) -> !3builtin_comp2  (!3builtin_comp3  (.8) (.10) (.12)) (.14)) in
+   let !3builtin_comp3_func[(.14,1)] = Coh([[[[[][][[]]]]]], !3builtin_comp3  (.8) (.10) (.12) -> !3builtin_comp3  (.8) (.10) (.13)) in
+   let _factor_id(3,2,1) = Coh([], !3builtin_id  (!2builtin_comp2  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) -> !3builtin_comp2  (eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (UBPad.p(3)  (.0))) in
+   let intch_src^-1 = Coh([[[[[][][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp3  (.8) (.10) (.12)) (.14)) -> !3builtin_comp2  (!3builtin_comp3  (.8) (.10) (.12)) (.14)) in
+   let !3builtin_comp3_func[(.10,1)] = Coh([[[[[[]][][]]]]], !3builtin_comp3  (.8) (.12) (.14) -> !3builtin_comp3  (.9) (.12) (.14)) in
+   let !3builtin_comp3_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} {.8,.6 -> .7} {.9,.6 -> .7} (.10,.8 -> .9) {.11,.4 -> .5} (.12,.7 -> .11) {.13,.4 -> .5} (.14,.11 -> .13) => !3builtin_comp3_func[(.10,1)]  (.10) (.12) (.14) in 
+   let !4builtin_comp6 = Coh([[[[[[][][][][][]]]]]], .8 -> .19) in
+   !4builtin_comp6  (!3_ehnat_step1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2))) (!3builtin_comp2_func[(.12,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (_factor_id(3,2,1)  (.0))) (!3assoc  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (UBPad.p(3)  (.0))) (!3builtin_comp2_func[(.10,1)]  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp5  (!3assoc  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_comp2_func[(.10,1)]  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp9  (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.10,1)]  (!4builtin_comp3  (intch_tgt^-1  (.1) (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (.2) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]_red_func[(.10,1) (.16,1)]_op{5}  (!1BPad.p(2)^-1_func[(.8,1)]  (.1)) (!1BPad.p(2)_op{1}^-1_func[(.8,1)]  (.2))) (intch_src^-1  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.12,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]_red_func[(.10,1) (.16,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp7  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.10,1)]  (!2intch_src^-1_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.12,1)]  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp11  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.10,1)]  (!2builtin_comp3^-1_func[(.14,1)][(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp2  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.12,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.Repadding(1) )) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.14,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.Repadding(1) )) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1^-1_func[(.8,2)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.16,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) )) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.18,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3^-1_func[(.8,1)][(.12,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.14,1)]  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt^-1_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp7  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.10,1)]  (!2intch_src^-1_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.12,1)]  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp11  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.10,1)]  (!2builtin_comp3^-1_func[(.14,1)][(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!2builtin_comp2  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.12,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.Repadding(1) )) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.14,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.Repadding(1) )) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1^-1_func[(.8,2)]  (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.16,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) )) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.18,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3^-1_func[(.8,1)][(.12,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.14,1)]  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt^-1_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!3builtin_comp3  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!3builtin_comp3  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.14,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp9  (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.10,1)]  (!2_builtin_assoc^-1_func[(.10,1) (.18,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp2  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.12,1)]  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp2  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3^-1_func[(.12,1)][(.8,1) (.16,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_id  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_id  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.14,1)]  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_id  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor^-1_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.16,1)]  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id^-1_func[(.8,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.16,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)^-1_func[(.8,1) (.14,1)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_assc  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_comp2_func[(.12,1)]  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp7  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp3_func[(.10,1)]  (!2intch_src^-1_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp3_func[(.12,1)]  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp11  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.10,1)]  (!2builtin_comp3^-1_func[(.14,1)][(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!2builtin_comp2  (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0)))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.12,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc^-1_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.Repadding(2) )) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.14,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!4builtin_comp3  (intch_tgt^-1  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.Repadding(2) )) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1^-1_func[(.8,2)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(2)  (.0))) (intch_src^-1  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (ΣUToURepad.Repadding(2) ) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(2)  (.0)))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (ΣUToURepad.Repadding(2) ) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.16,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc^-1_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) )) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.18,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3^-1_func[(.8,1)][(.12,1)]  (ΣUToURepad.f(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp3_func[(.14,1)]  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt^-1_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (!3assoc  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))))) (UBPad.p(3)  (.0))) (!3_unbiasor_left  (eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (UBPad.Padding(3)_func[(.3,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(3)  (.0))) (!3builtin_comp3_func[(.10,1)]  (_eh_to_p(3,2,1)  (.0)) (UBPad.Padding(3)_func[(.3,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(3)  (.0))).

From 32b39cd66a6d762c3e3396ca2bebbb8fdfd4bbc3 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Wed, 1 Oct 2025 08:40:18 +0200
Subject: [PATCH 12/30] [printing] fix printing issue

---
 lib/equality.ml  |  4 ++--
 lib/kernel.ml    | 14 +++++++-------
 lib/printing.ml  | 21 +++++++++++++--------
 lib/printing.mli |  5 +++++
 test.t/run.t     |  6 ------
 5 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/lib/equality.ml b/lib/equality.ml
index dd8549bc..69fd097b 100644
--- a/lib/equality.ml
+++ b/lib/equality.ml
@@ -32,10 +32,10 @@ struct
       TmT.t * Unchecked_types(CohT)(TmT).sub
   end) =
   struct
-    module P = Printing.Printing (CohT) (TmT)
-    module Printing = P.Make (Coh) (Tm)
     module U = Unchecked.Unchecked (CohT) (TmT)
     module Unchecked = U.Make (Coh) (Tm)
+    module P = Printing.Printing (CohT) (TmT) (Unchecked)
+    module Printing = P.Make (Coh) (Tm)
 
     let rec is_equal_ps ps1 ps2 =
       match (ps1, ps2) with
diff --git a/lib/kernel.ml b/lib/kernel.ml
index e35d5260..12bbaa06 100644
--- a/lib/kernel.ml
+++ b/lib/kernel.ml
@@ -34,7 +34,7 @@ end = struct
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
-  open Printing (Coh) (Tm)
+  open Printing (Coh) (Tm) (Unchecked)
   module Printing = Make (Coh) (Tm)
 
   let tbl : (Ctx.t * PS.t * Types.sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
@@ -105,7 +105,7 @@ end = struct
   open Unchecked_types (Coh) (Tm)
   module U = Unchecked (Coh) (Tm)
   module Unchecked = U.Make (Coh) (Tm)
-  module P = Printing (Coh) (Tm)
+  module P = Printing (Coh) (Tm) (Unchecked)
   module Printing = P.Make (Coh) (Tm)
   module E = Equality (Coh) (Tm)
   module Equality = E.Make (Coh) (Tm)
@@ -184,7 +184,7 @@ end = struct
 
   module U = Unchecked (Coh) (Tm)
   module Unchecked = U.Make (Coh) (Tm)
-  module P = Printing (Coh) (Tm)
+  module P = Printing (Coh) (Tm) (Unchecked)
   module Printing = P.Make (Coh) (Tm)
   module E = Equality (Coh) (Tm)
   module Equality = E.Make (Coh) (Tm)
@@ -344,7 +344,7 @@ end = struct
   module Types = Unchecked_types (Coh) (Tm)
   module U = Unchecked (Coh) (Tm)
   module Unchecked = U.Make (Coh) (Tm)
-  module P = Printing (Coh) (Tm)
+  module P = Printing (Coh) (Tm) (Unchecked)
   module Printing = P.Make (Coh) (Tm)
   module E = Equality (Coh) (Tm)
   module Equality = E.Make (Coh) (Tm)
@@ -470,7 +470,7 @@ end = struct
   module Unchecked = U.Make (Coh) (Tm)
   module Types = Unchecked_types (Coh) (Tm)
   module Display_maps = Unchecked.Display_maps
-  module P = Printing (Coh) (Tm)
+  module P = Printing (Coh) (Tm) (Unchecked)
   module Printing = P.Make (Coh) (Tm)
   module E = Equality (Coh) (Tm)
   module Equality = E.Make (Coh) (Tm)
@@ -680,7 +680,7 @@ end = struct
   open Unchecked (Coh) (Tm)
   module Unchecked = Make (Coh) (Tm)
   module Display_maps = Unchecked.Display_maps
-  open Printing (Coh) (Tm)
+  open Printing (Coh) (Tm) (Unchecked)
   module Printing = Make (Coh) (Tm)
 
   let ps = function Inv (data, _) -> data.ps | NonInv (data, _) -> data.ps
@@ -839,7 +839,7 @@ end
 module U = Unchecked (Coh) (Tm)
 module Unchecked = U.Make (Coh) (Tm)
 module Display_maps = Unchecked.Display_maps
-module P = Printing (Coh) (Tm)
+module P = Printing (Coh) (Tm) (Unchecked)
 module Printing = P.Make (Coh) (Tm)
 module E = Equality (Coh) (Tm)
 module Equality = E.Make (Coh) (Tm)
diff --git a/lib/printing.ml b/lib/printing.ml
index ff436864..6af4351c 100644
--- a/lib/printing.ml
+++ b/lib/printing.ml
@@ -5,6 +5,11 @@ module Printing (CohT : sig
   type t
 end) (TmT : sig
   type t
+end) (App : sig
+  val tm_apply_sub :
+    Unchecked_types(CohT)(TmT).tm ->
+    Unchecked_types(CohT)(TmT).sub ->
+    Unchecked_types(CohT)(TmT).tm
 end) =
 struct
   open Unchecked_types (CohT) (TmT)
@@ -65,14 +70,14 @@ struct
               let func = Coh.func_data c in
               Printf.sprintf "(%s%s)" (Coh.to_string c)
                 (sub_ps_to_string ~func s)
-        | App (t, s) ->
-            let name =
-              match Tm.name t with Some name -> name | None -> "anonymous_tm"
-            in
-            let func = Tm.func_data t in
-            let str_s, expl = sub_to_string ?func s in
-            let expl_str = if expl then "@" else "" in
-            Printf.sprintf "(%s%s%s)" expl_str name str_s
+        | App (t, s) -> (
+            match Tm.name t with
+            | Some name ->
+                let func = Tm.func_data t in
+                let str_s, expl = sub_to_string ?func s in
+                let expl_str = if expl then "@" else "" in
+                Printf.sprintf "(%s%s%s)" expl_str name str_s
+            | None -> tm_to_string (App.tm_apply_sub (Tm.develop t) s))
 
       and sub_ps_to_string ?(func = []) s =
         match func with
diff --git a/lib/printing.mli b/lib/printing.mli
index 4956337a..76ad0332 100644
--- a/lib/printing.mli
+++ b/lib/printing.mli
@@ -5,6 +5,11 @@ module Printing (Coh : sig
   type t
 end) (Tm : sig
   type t
+end) (_ : sig
+  val tm_apply_sub :
+    Unchecked_types(Coh)(Tm).tm ->
+    Unchecked_types(Coh)(Tm).sub ->
+    Unchecked_types(Coh)(Tm).tm
 end) : sig
   open Unchecked_types(Coh)(Tm)
 
diff --git a/test.t/run.t b/test.t/run.t
index b9c755d2..ae71b1fa 100644
--- a/test.t/run.t
+++ b/test.t/run.t
@@ -704,8 +704,6 @@
   [=^.^=] check cylcomp(3,1,3)
   [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.26,1) (.22,1) (.18,1) (.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .4 .18)] .23) (!1builtin_comp3 (intch_src_op{3} .3 .17 .23) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .17 .23) (builtin_comp2_op{2} .3 [.25]) (assoc_op{3} .3 .11 .21) (builtin_comp2_op{2} [.13] .21) (builtin_assc_op{3} .10 .8 .21))) (intch_tgt_op{3} .10 .8 .21))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .23) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .23) (builtin_comp2_op{2} .2 [.24]) (assoc_op{3} .2 .11 .20) (builtin_comp2_op{2} [.12] .20) (builtin_assc_op{3} .10 .7 .20))) (intch_tgt_op{3} .10 .7 .20)) (builtin_comp2_op{2} .10 [(builtin_comp2_func[(.4,1) (.8,1)]_op{3} .9 .22)])).
   [=^.^=] check cylcomp(3,2,3)
-  [=D.D=] substitution: (.0, .0) (.1, .6) (.2, (builtin_comp2 .2 .11)) (.3, (builtin_comp2 .3 .11)) (.4, (builtin_comp2 [.4] .11)) (.5, (builtin_comp2 .10 .7)) (.6, (builtin_comp2 .10 .8)) (.7, (builtin_comp2 .10 [.9])) (.8, .12) (.9, .13) (.10, .14) (.11, (builtin_comp2 .15 .11)) (.12, (builtin_comp2 [.16] .11)) (.13, (builtin_comp2 .10 .17)) (.14, (builtin_comp2 .10 [.18])) (.15, .19) (.16, .20)
-
   [=I.I=] valid term builtin_conecomp(3,2,3) of type (!1builtin_comp2 (builtin_comp2 [(!1builtin_comp2 .4 .16)] .11) .19) -> (!1builtin_comp2 .12 (builtin_comp2_func[(.4,1)]_op{1} (!1builtin_comp2 .9 .18) .10)).
   [=^.^=] check cylcomp(3,1,2)
   [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.14,1) (.9,1) (.4,1)]_op{3} of type (!1builtin_comp2 (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .16)] .19) (!1builtin_comp3 (intch_src_op{3} .3 .16 .19) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .16 .19) (builtin_comp2_op{2} .3 [.20]) (assoc_op{3} .3 .11 .18) (builtin_comp2_op{2} [.13] .18) (builtin_assc_op{3} .10 .8 .18))) (intch_tgt_op{3} .10 .8 .18))) -> (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .16 .19) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .16 .19) (builtin_comp2_op{2} .2 [.20]) (assoc_op{3} .2 .11 .18) (builtin_comp2_op{2} [.12] .18) (builtin_assc_op{3} .10 .7 .18))) (intch_tgt_op{3} .10 .7 .18)) (builtin_comp2_op{2} .10 [(builtin_comp2_op{2} [.9] .18)])).
@@ -716,10 +714,6 @@
   [=^.^=] check cylcomp(4,2,4)
   [=I.I=] valid term builtin_conecomp(3,2,3)_func[(.32,1) (.28,1) (.24,1) (.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (!1builtin_comp2 [.6] [.24]) .15)] .29) (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .5 .23 .15)] .29) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.23] .15) .29) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.5] .15) (builtin_comp2_op{2} [.23] .15) .29) (!1builtin_comp2 (builtin_comp2_op{2} [.5] .15) [.31]) (!1assoc (builtin_comp2_op{2} [.5] .15) .17 (builtin_comp2_op{2} .14 [.27])) (!1builtin_comp2 [.19] (builtin_comp2_op{2} .14 [.27])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.27])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.12]) (builtin_comp2_op{2} .14 [.27]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .12 .27)]))) -> (!2builtin_comp2 (!2builtin_comp3 (!1builtin_comp2 [(builtin_comp_1_0_intch_op{4} .4 .22 .15)] .29) (!2builtin_comp3 (!1intch_src (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .29) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp5 (!1builtin_assc (builtin_comp2_op{2} [.4] .15) (builtin_comp2_op{2} [.22] .15) .29) (!1builtin_comp2 (builtin_comp2_op{2} [.4] .15) [.30]) (!1assoc (builtin_comp2_op{2} [.4] .15) .17 (builtin_comp2_op{2} .14 [.26])) (!1builtin_comp2 [.18] (builtin_comp2_op{2} .14 [.26])) (!1builtin_assc .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.26])))) (!1intch_tgt .16 (builtin_comp2_op{2} .14 [.11]) (builtin_comp2_op{2} .14 [.26]))) (!1builtin_comp2 .16 [(builtin_comp_1_0_intch_op{1}^-1 .14 .11 .26)])) (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (!1builtin_comp2 [.13] [.28]))])).
   [=^.^=] check cylcomp(4,3,4)
-  [=D.D=] substitution: (.0, .0) (.1, .6) (.2, (builtin_comp2 .2 .11)) (.3, (builtin_comp2 .3 .11)) (.4, (builtin_comp2 [.4] .11)) (.5, (builtin_comp2 .10 .7)) (.6, (builtin_comp2 .10 .8)) (.7, (builtin_comp2 .10 [.9])) (.8, .12) (.9, .13) (.10, .14) (.11, (builtin_comp2 .15 .11)) (.12, (builtin_comp2 [.16] .11)) (.13, (builtin_comp2 .10 .17)) (.14, (builtin_comp2 .10 [.18])) (.15, .19) (.16, .20)
-
-  [=D.D=] substitution: (.0, .0) (.1, .8) (.2, (builtin_comp2 .2 .15)) (.3, (builtin_comp2 .3 .15)) (.4, (builtin_comp2 [.4] .15)) (.5, (builtin_comp2 [.5] .15)) (.6, (builtin_comp2 [[.6]] .15)) (.7, (builtin_comp2 .14 .9)) (.8, (builtin_comp2 .14 .10)) (.9, (builtin_comp2 .14 [.11])) (.10, (builtin_comp2 .14 [.12])) (.11, (builtin_comp2 .14 [[.13]])) (.12, .16) (.13, .17) (.14, .18) (.15, .19) (.16, .20) (.17, (builtin_comp2 [.21] .15)) (.18, (builtin_comp2 [[.22]] .15)) (.19, (builtin_comp2 .14 [.23])) (.20, (builtin_comp2 .14 [[.24]])) (.21, .25) (.22, .26)
-
   [=I.I=] valid term builtin_conecomp(4,3,4) of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2 [[(!2builtin_comp2 .6 .22)]] .15)] .17) .25) -> (!2builtin_comp2 .18 (!1builtin_comp2 .16 [(builtin_comp2_func[(.6,2)]_op{1} (!2builtin_comp2 .13 .24) .14)])).
   [=^.^=] check cylcomp(4,1,2)
   [=I.I=] valid term builtin_conecomp(2,1,2)_func[(.14,1) (.9,1) (.4,1)]_op{3}_func[(.20,1) (.13,1) (.6,1)]_op{4} of type (!2builtin_comp2 (!1builtin_comp2 [(builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} (builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .6 .22) .25)] (!1builtin_comp3 (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24))) (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 [(intch_src_func[(.4,1)]_op{3} .5 .22 .25)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.5] .22)] .25)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1)]_op{3} .5 .22 .25) (builtin_comp2_func[(.8,1)][(.4,1)]_op{3} .5 .26) (assoc_func[(.4,1)]_op{3} .5 .15 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .19 .24) (builtin_assc_func[(.6,1)]_op{3} .14 .12 .24)))] (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) [(intch_tgt_func[(.6,1)]_op{3} .14 .12 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.12] .24)])))) -> (!2builtin_comp2 (!2builtin_comp3 (intch_tgt_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp5_red_func[(.6,1)]_op{3} (!2builtin_comp7 (!1builtin_assc_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25) (intch_src_op{3} .3 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 [(intch_src_func[(.4,1)]_op{3} .4 .22 .25)] (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} [(builtin_comp2_op{2} [.4] .22)] .25)) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .3 .22 .25) (builtin_comp2_op{2} .3 [.26]) (assoc_op{3} .3 .15 .24) (builtin_comp2_op{2} [.17] .24) (builtin_assc_op{3} .14 .10 .24))) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) [(builtin_comp2_red_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} (!1builtin_comp5_func[(.2~,1) (.3~,1) (.4~,1) (.5~,1) (.6~,1) (.7~,1) (.8~,1) (.9~,1) (.10~,1) (.11~,1) (.12~,1)]_op{3} (builtin_assc_func[(.4,1)]_op{3} .4 .22 .25) (builtin_comp2_func[(.8,1)][(.4,1)]_op{3} .4 .26) (assoc_func[(.4,1)]_op{3} .4 .15 .24) (builtin_comp2_func[(.4,1)][(.2~,1) (.3~,1) (.4~,1)]_op{3} .18 .24) (builtin_assc_func[(.6,1)]_op{3} .14 .11 .24)))] (intch_tgt_op{3} .14 .10 .24)) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (builtin_comp2_red_func[(.4,1)]_op{3} (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)])) (intch_tgt_op{3} .14 .10 .24)) (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) [(intch_tgt_func[(.6,1)]_op{3} .14 .11 .24)]) (!1builtin_assc_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)])))) (intch_src_op{3} (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24) (builtin_comp2_op{2} .14 [(builtin_comp2_op{2} [.11] .24)]))) (!1builtin_comp2 (!1builtin_comp3 (intch_src_op{3} .2 .22 .25) (builtin_comp2_red_func[(.4,1)]_op{3} (!1builtin_comp5 (builtin_assc_op{3} .2 .22 .25) (builtin_comp2_op{2} .2 [.26]) (assoc_op{3} .2 .15 .24) (builtin_comp2_op{2} [.16] .24) (builtin_assc_op{3} .14 .9 .24))) (intch_tgt_op{3} .14 .9 .24)) [(builtin_comp2_func[(.6,1)]_red_func[(.8,1)]_op{3} .14 (builtin_comp2_func[(.4,1)]_red_func[(.6,1)]_op{3} .13 .24))])).

From b41c9f5699fd9250e1e8825b1960381cc5be0c39 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 30 Sep 2025 16:45:26 +0200
Subject: [PATCH 13/30] [rocq] demo for the rocqshop 2025

---
 demo/demo_rocqshop/Demo.v      | 10 ++++++++++
 demo/demo_rocqshop/_CoqProject |  2 ++
 demo/demo_rocqshop/demo1.catt  |  5 +++++
 demo/demo_rocqshop/demo2.catt  | 22 ++++++++++++++++++++++
 4 files changed, 39 insertions(+)
 create mode 100644 demo/demo_rocqshop/Demo.v
 create mode 100644 demo/demo_rocqshop/_CoqProject
 create mode 100644 demo/demo_rocqshop/demo1.catt
 create mode 100644 demo/demo_rocqshop/demo2.catt

diff --git a/demo/demo_rocqshop/Demo.v b/demo/demo_rocqshop/Demo.v
new file mode 100644
index 00000000..aa86d6fd
--- /dev/null
+++ b/demo/demo_rocqshop/Demo.v
@@ -0,0 +1,10 @@
+From Catt Require Import Loader.
+
+Catt "trans" "whisk" From File "demo1.catt".
+
+Print catt_coh_trans.
+Print catt_coh_whisk.
+
+Catt "eh" From File "demo2.catt".
+Print catt_tm_eh.
+Eval cbv in catt_tm_eh.
diff --git a/demo/demo_rocqshop/_CoqProject b/demo/demo_rocqshop/_CoqProject
new file mode 100644
index 00000000..a5f12099
--- /dev/null
+++ b/demo/demo_rocqshop/_CoqProject
@@ -0,0 +1,2 @@
+-I ../../_build/install/default/lib/
+-Q ../../_build/default/coq_plugin/theories/ Catt
\ No newline at end of file
diff --git a/demo/demo_rocqshop/demo1.catt b/demo/demo_rocqshop/demo1.catt
new file mode 100644
index 00000000..94817b58
--- /dev/null
+++ b/demo/demo_rocqshop/demo1.catt
@@ -0,0 +1,5 @@
+coh trans (x(p)y(q)z) : x -> z
+# (x(p)y(q)z) : x ==p== y ==q== z,
+# result x == z
+
+coh whisk (x(p(a)q)y(r)z) : trans p r -> trans q r
diff --git a/demo/demo_rocqshop/demo2.catt b/demo/demo_rocqshop/demo2.catt
new file mode 100644
index 00000000..beb08691
--- /dev/null
+++ b/demo/demo_rocqshop/demo2.catt
@@ -0,0 +1,22 @@
+coh unitl (x(f)y) : comp (id _) f -> f
+coh unit (x) : comp (id x) (id x) -> id x
+coh lsimp (x) : (unitl (id x)) -> unit x
+coh Ilsimp (x) : I (unitl (id x)) -> I (unit x)
+coh exch (x(f(a)g)y(h(b)k)z) : comp (comp _ [b]) (id (comp f k)) (comp [a] _) -> comp [a] [b]
+
+coh eh1 (x(f(a)g(b)h)y) :
+comp a b -> comp (I (unitl f))
+                 (comp (comp _ [a]) (comp (unitl g) (I (op { 1 } (unitl g)))) (comp [b] _))
+                 (op { 1 } (unitl h))
+
+let eh2 (x : *) (a : id x -> id x) (b : id x -> id x) =
+comp [Ilsimp _]
+     [comp (comp _ [comp (comp [lsimp _] [op { 1 } (Ilsimp _)]) (U (unit _))] _)
+           (exch b a)]
+     [op { 1 } (lsimp _)]
+
+let ehhalf (x : *) (a : id x -> id x) (b : id x -> id x) =
+comp (eh1 a b) (eh2 a b)
+
+let eh (x : *) (a : id x -> id x) (b : id x -> id x) =
+comp (ehhalf a b) (I (op { 1 } (ehhalf b a)))

From 5c5e2683253fb621a26836ba6d4b47d410e68b55 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Wed, 1 Oct 2025 16:20:07 +0200
Subject: [PATCH 14/30] [rocq] update rocq 9.0

---
 coq_plugin/src/export.ml |  8 ++++----
 flake.lock               | 18 +++++++++---------
 flake.nix                |  8 ++++++--
 web/web.ml               |  4 ++--
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/coq_plugin/src/export.ml b/coq_plugin/src/export.ml
index 7a849a4a..09bbb7db 100644
--- a/coq_plugin/src/export.ml
+++ b/coq_plugin/src/export.ml
@@ -27,11 +27,11 @@ let anon () =
   Printf.sprintf "anonymous_term_%d" !counter
 
 let c_Q env sigma =
-  let gr = Coqlib.lib_ref "core.eq.type" in
+  let gr = Rocqlib.lib_ref "core.eq.type" in
   Evd.fresh_global env sigma gr
 
 let c_R env sigma =
-  let gr = Coqlib.lib_ref "core.eq.refl" in
+  let gr = Rocqlib.lib_ref "core.eq.refl" in
   Evd.fresh_global env sigma gr
 
 let rec find_db ctx x =
@@ -62,7 +62,7 @@ end = struct
 
   let retrieve_lambda value sigma =
     let build_econstr name =
-      let gr = Coqlib.lib_ref ("catt_" ^ name) in
+      let gr = Rocqlib.lib_ref ("catt_" ^ name) in
       let env = Global.env () in
       let sigma, econstr = Evd.fresh_global env sigma gr in
       (env, sigma, econstr)
@@ -79,7 +79,7 @@ end = struct
     let gr =
       Declare.declare_definition ~info ~cinfo ~opaque:false ~body sigma
     in
-    Coqlib.register_ref ("catt_" ^ name) gr;
+    Rocqlib.register_ref Local ("catt_" ^ name) gr;
     let env = Global.env () in
     let sigma, econstr = Evd.fresh_global env sigma gr in
     let _ = Hashtbl.add tbl value name in
diff --git a/flake.lock b/flake.lock
index bd12035c..2cb5b01a 100644
--- a/flake.lock
+++ b/flake.lock
@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1726560853,
-        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -20,11 +20,11 @@
     },
     "nix-filter": {
       "locked": {
-        "lastModified": 1730207686,
-        "narHash": "sha256-SCHiL+1f7q9TAnxpasriP6fMarWE5H43t25F5/9e28I=",
+        "lastModified": 1757882181,
+        "narHash": "sha256-+cCxYIh2UNalTz364p+QYmWHs0P+6wDhiWR4jDIKQIU=",
         "owner": "numtide",
         "repo": "nix-filter",
-        "rev": "776e68c1d014c3adde193a18db9d738458cd2ba4",
+        "rev": "59c44d1909c72441144b93cf0f054be7fe764de5",
         "type": "github"
       },
       "original": {
@@ -35,11 +35,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1731139594,
-        "narHash": "sha256-IigrKK3vYRpUu+HEjPL/phrfh7Ox881er1UEsZvw9Q4=",
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "76612b17c0ce71689921ca12d9ffdc9c23ce40b2",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index c4fa8c9c..bb0a81a1 100644
--- a/flake.nix
+++ b/flake.nix
@@ -121,8 +121,12 @@
             src = sources.coq-plugin;
             nativeBuildInputs = [ ];
 
-            buildInputs =
-              [ self.packages.${system}.catt pkgs.dune_3 pkgs.opam pkgs.coq ];
+            buildInputs = [
+              self.packages.${system}.catt
+              pkgs.dune_3
+              pkgs.opam
+              pkgs.rocq-core
+            ];
             mlPlugin = true;
             useDune = true;
 
diff --git a/web/web.ml b/web/web.ml
index 321ba0b3..3851d8a3 100644
--- a/web/web.ml
+++ b/web/web.ml
@@ -4,7 +4,7 @@ module Dom = Js_of_ocaml.Dom
 module Sys_js = Js_of_ocaml.Sys_js
 module Html = Js_of_ocaml.Dom_html
 module Js = Js_of_ocaml.Js
-module Firebug = Js_of_ocaml.Firebug
+module Console = Js_of_ocaml.Console
 
 let doc = Html.document
 
@@ -19,7 +19,7 @@ let button ~id txt action =
   b##.id := Js.string id;
   b
 
-let _debug s = Firebug.console##debug (Js.string s)
+let _debug s = Console.console##debug (Js.string s)
 
 let run_action s =
   try

From c059acee80558a86899edef5a9f5b7814838e82a Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Wed, 1 Oct 2025 16:32:06 +0200
Subject: [PATCH 15/30] [rocq] use anonymous variable names

---
 coq_plugin/src/export.ml | 18 +++---------------
 1 file changed, 3 insertions(+), 15 deletions(-)

diff --git a/coq_plugin/src/export.ml b/coq_plugin/src/export.ml
index 09bbb7db..88b0c825 100644
--- a/coq_plugin/src/export.ml
+++ b/coq_plugin/src/export.ml
@@ -12,14 +12,6 @@ let run_catt_on_file f =
   | Ok f -> Command.exec ~loop_fn:Prover.loop f
   | Error () -> ()
 
-let rec catt_var_to_coq_name v =
-  match v with
-  | Var.Db i -> "catt_db_" ^ string_of_int i
-  | Var.Name s -> "catt_name_" ^ s
-  | Var.New i -> "catt_new_" ^ string_of_int i
-  | Var.Plus v -> catt_var_to_coq_name v ^ "_plus"
-  | Var.Bridge v -> catt_var_to_coq_name v ^ "_bridge"
-
 let counter = ref 0
 
 let anon () =
@@ -74,7 +66,7 @@ end = struct
     let body = Evarutil.nf_evar sigma body in
     let info = Declare.Info.make () in
     let cinfo =
-      Declare.CInfo.make ~name:Id.(of_string ("catt_" ^ name)) ~typ:None ()
+      Declare.CInfo.make ~name:(Id.of_string ("catt_" ^ name)) ~typ:None ()
     in
     let gr =
       Declare.declare_definition ~info ~cinfo ~opaque:false ~body sigma
@@ -138,16 +130,12 @@ end = struct
   (* translate a catt context into a coq lambda abstraction *)
   let rec ctx_to_lambda env sigma obj_type eq_type refl ctx inner_tm =
     match ctx with
-    | [] ->
-        ( sigma,
-          EConstr.mkLambda
-            (nameR (Names.Id.of_string "catt_Obj"), obj_type, inner_tm) )
+    | [] -> (sigma, EConstr.mkLambda (anonR, obj_type, inner_tm))
     | (x, (ty, _)) :: ctx ->
         let env, sigma, ty =
           ty_to_econstr env sigma obj_type eq_type refl ctx ty
         in
-        let id_lambda = Names.Id.of_string (catt_var_to_coq_name x) in
-        let lambda = EConstr.mkLambda (nameR id_lambda, ty, inner_tm) in
+        let lambda = EConstr.mkLambda (anonR, ty, inner_tm) in
         ctx_to_lambda env sigma obj_type eq_type refl ctx lambda
 
   (* translate a catt type into a coq type *)

From 545e78641d701658b047c9d37ce6db5e7e69644a Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Wed, 1 Oct 2025 16:37:04 +0200
Subject: [PATCH 16/30] [rocq] rename coq to rocq

---
 {coq_plugin => rocq_plugin}/_CoqProject           | 0
 {coq_plugin => rocq_plugin}/src/coq_plugin.mlpack | 0
 {coq_plugin => rocq_plugin}/src/dune              | 0
 {coq_plugin => rocq_plugin}/src/export.ml         | 0
 {coq_plugin => rocq_plugin}/src/export.mli        | 0
 {coq_plugin => rocq_plugin}/src/g_catt.mlg        | 0
 {coq_plugin => rocq_plugin}/theories/Loader.v     | 0
 {coq_plugin => rocq_plugin}/theories/Test.v       | 0
 {coq_plugin => rocq_plugin}/theories/dune         | 0
 9 files changed, 0 insertions(+), 0 deletions(-)
 rename {coq_plugin => rocq_plugin}/_CoqProject (100%)
 rename {coq_plugin => rocq_plugin}/src/coq_plugin.mlpack (100%)
 rename {coq_plugin => rocq_plugin}/src/dune (100%)
 rename {coq_plugin => rocq_plugin}/src/export.ml (100%)
 rename {coq_plugin => rocq_plugin}/src/export.mli (100%)
 rename {coq_plugin => rocq_plugin}/src/g_catt.mlg (100%)
 rename {coq_plugin => rocq_plugin}/theories/Loader.v (100%)
 rename {coq_plugin => rocq_plugin}/theories/Test.v (100%)
 rename {coq_plugin => rocq_plugin}/theories/dune (100%)

diff --git a/coq_plugin/_CoqProject b/rocq_plugin/_CoqProject
similarity index 100%
rename from coq_plugin/_CoqProject
rename to rocq_plugin/_CoqProject
diff --git a/coq_plugin/src/coq_plugin.mlpack b/rocq_plugin/src/coq_plugin.mlpack
similarity index 100%
rename from coq_plugin/src/coq_plugin.mlpack
rename to rocq_plugin/src/coq_plugin.mlpack
diff --git a/coq_plugin/src/dune b/rocq_plugin/src/dune
similarity index 100%
rename from coq_plugin/src/dune
rename to rocq_plugin/src/dune
diff --git a/coq_plugin/src/export.ml b/rocq_plugin/src/export.ml
similarity index 100%
rename from coq_plugin/src/export.ml
rename to rocq_plugin/src/export.ml
diff --git a/coq_plugin/src/export.mli b/rocq_plugin/src/export.mli
similarity index 100%
rename from coq_plugin/src/export.mli
rename to rocq_plugin/src/export.mli
diff --git a/coq_plugin/src/g_catt.mlg b/rocq_plugin/src/g_catt.mlg
similarity index 100%
rename from coq_plugin/src/g_catt.mlg
rename to rocq_plugin/src/g_catt.mlg
diff --git a/coq_plugin/theories/Loader.v b/rocq_plugin/theories/Loader.v
similarity index 100%
rename from coq_plugin/theories/Loader.v
rename to rocq_plugin/theories/Loader.v
diff --git a/coq_plugin/theories/Test.v b/rocq_plugin/theories/Test.v
similarity index 100%
rename from coq_plugin/theories/Test.v
rename to rocq_plugin/theories/Test.v
diff --git a/coq_plugin/theories/dune b/rocq_plugin/theories/dune
similarity index 100%
rename from coq_plugin/theories/dune
rename to rocq_plugin/theories/dune

From 1ab9705329384be64025c33419df708c8b2f9f01 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Wed, 1 Oct 2025 16:59:55 +0200
Subject: [PATCH 17/30] [refactor] split the sources into directories

---
 lib/dune                                        | 5 +----
 lib/{ => elaboration}/elaborate.ml              | 0
 lib/{ => elaboration}/elaborate.mli             | 0
 lib/{ => elaboration}/translate_raw.ml          | 0
 lib/{ => elaboration}/translate_raw.mli         | 0
 lib/{ => internals}/equality.ml                 | 0
 lib/{ => internals}/equality.mli                | 0
 lib/{ => internals}/kernel.ml                   | 0
 lib/{ => internals}/kernel.mli                  | 0
 lib/{ => internals}/printing.ml                 | 0
 lib/{ => internals}/printing.mli                | 0
 lib/{ => internals}/unchecked.ml                | 0
 lib/{ => internals}/unchecked.mli               | 0
 lib/{ => internals}/unchecked_types.ml          | 0
 lib/{ => internals}/unchecked_types.mli         | 0
 lib/{ => lib}/command.ml                        | 0
 lib/{ => lib}/command.mli                       | 0
 lib/{ => lib}/common.ml                         | 0
 lib/{ => lib}/common.mli                        | 0
 lib/{ => lib}/environment.ml                    | 0
 lib/{ => lib}/environment.mli                   | 0
 lib/{ => lib}/error.ml                          | 0
 lib/{ => lib}/error.mli                         | 0
 lib/{ => lib}/io.ml                             | 0
 lib/{ => lib}/io.mli                            | 0
 lib/{ => lib}/meta.ml                           | 0
 lib/{ => lib}/meta.mli                          | 0
 lib/{ => lib}/raw.ml                            | 0
 lib/{ => lib}/raw.mli                           | 0
 lib/{ => lib}/raw_types.mli                     | 0
 lib/{ => lib}/settings.ml                       | 0
 lib/{ => lib}/settings.mli                      | 0
 lib/{ => lib}/std.ml                            | 0
 lib/{ => lib}/std.mli                           | 0
 lib/{ => meta_operations}/builtin.ml            | 0
 lib/{ => meta_operations}/builtin.mli           | 0
 lib/{ => meta_operations}/cones.ml              | 0
 lib/{ => meta_operations}/cones.mli             | 0
 lib/{ => meta_operations}/construct.ml          | 0
 lib/{ => meta_operations}/construct.mli         | 0
 lib/{ => meta_operations}/cubical_composite.ml  | 0
 lib/{ => meta_operations}/cubical_composite.mli | 0
 lib/{ => meta_operations}/cylinders.ml          | 0
 lib/{ => meta_operations}/cylinders.mli         | 0
 lib/{ => meta_operations}/eh.ml                 | 0
 lib/{ => meta_operations}/eh.mli                | 0
 lib/{ => meta_operations}/functorialisation.ml  | 0
 lib/{ => meta_operations}/functorialisation.mli | 0
 lib/{ => meta_operations}/inverse.ml            | 0
 lib/{ => meta_operations}/inverse.mli           | 0
 lib/{ => meta_operations}/opposite.ml           | 0
 lib/{ => meta_operations}/opposite.mli          | 0
 lib/{ => meta_operations}/padding.ml            | 0
 lib/{ => meta_operations}/padding.mli           | 0
 lib/{ => meta_operations}/ps_reduction.ml       | 0
 lib/{ => meta_operations}/ps_reduction.mli      | 0
 lib/{ => meta_operations}/suspension.ml         | 0
 lib/{ => meta_operations}/suspension.mli        | 0
 lib/{ => meta_operations}/telescope.ml          | 0
 lib/{ => meta_operations}/telescope.mli         | 0
 lib/parser/dune                                 | 4 ++++
 lib/{ => parser}/lexer.mll                      | 0
 lib/{ => parser}/parser.mly                     | 0
 63 files changed, 5 insertions(+), 4 deletions(-)
 rename lib/{ => elaboration}/elaborate.ml (100%)
 rename lib/{ => elaboration}/elaborate.mli (100%)
 rename lib/{ => elaboration}/translate_raw.ml (100%)
 rename lib/{ => elaboration}/translate_raw.mli (100%)
 rename lib/{ => internals}/equality.ml (100%)
 rename lib/{ => internals}/equality.mli (100%)
 rename lib/{ => internals}/kernel.ml (100%)
 rename lib/{ => internals}/kernel.mli (100%)
 rename lib/{ => internals}/printing.ml (100%)
 rename lib/{ => internals}/printing.mli (100%)
 rename lib/{ => internals}/unchecked.ml (100%)
 rename lib/{ => internals}/unchecked.mli (100%)
 rename lib/{ => internals}/unchecked_types.ml (100%)
 rename lib/{ => internals}/unchecked_types.mli (100%)
 rename lib/{ => lib}/command.ml (100%)
 rename lib/{ => lib}/command.mli (100%)
 rename lib/{ => lib}/common.ml (100%)
 rename lib/{ => lib}/common.mli (100%)
 rename lib/{ => lib}/environment.ml (100%)
 rename lib/{ => lib}/environment.mli (100%)
 rename lib/{ => lib}/error.ml (100%)
 rename lib/{ => lib}/error.mli (100%)
 rename lib/{ => lib}/io.ml (100%)
 rename lib/{ => lib}/io.mli (100%)
 rename lib/{ => lib}/meta.ml (100%)
 rename lib/{ => lib}/meta.mli (100%)
 rename lib/{ => lib}/raw.ml (100%)
 rename lib/{ => lib}/raw.mli (100%)
 rename lib/{ => lib}/raw_types.mli (100%)
 rename lib/{ => lib}/settings.ml (100%)
 rename lib/{ => lib}/settings.mli (100%)
 rename lib/{ => lib}/std.ml (100%)
 rename lib/{ => lib}/std.mli (100%)
 rename lib/{ => meta_operations}/builtin.ml (100%)
 rename lib/{ => meta_operations}/builtin.mli (100%)
 rename lib/{ => meta_operations}/cones.ml (100%)
 rename lib/{ => meta_operations}/cones.mli (100%)
 rename lib/{ => meta_operations}/construct.ml (100%)
 rename lib/{ => meta_operations}/construct.mli (100%)
 rename lib/{ => meta_operations}/cubical_composite.ml (100%)
 rename lib/{ => meta_operations}/cubical_composite.mli (100%)
 rename lib/{ => meta_operations}/cylinders.ml (100%)
 rename lib/{ => meta_operations}/cylinders.mli (100%)
 rename lib/{ => meta_operations}/eh.ml (100%)
 rename lib/{ => meta_operations}/eh.mli (100%)
 rename lib/{ => meta_operations}/functorialisation.ml (100%)
 rename lib/{ => meta_operations}/functorialisation.mli (100%)
 rename lib/{ => meta_operations}/inverse.ml (100%)
 rename lib/{ => meta_operations}/inverse.mli (100%)
 rename lib/{ => meta_operations}/opposite.ml (100%)
 rename lib/{ => meta_operations}/opposite.mli (100%)
 rename lib/{ => meta_operations}/padding.ml (100%)
 rename lib/{ => meta_operations}/padding.mli (100%)
 rename lib/{ => meta_operations}/ps_reduction.ml (100%)
 rename lib/{ => meta_operations}/ps_reduction.mli (100%)
 rename lib/{ => meta_operations}/suspension.ml (100%)
 rename lib/{ => meta_operations}/suspension.mli (100%)
 rename lib/{ => meta_operations}/telescope.ml (100%)
 rename lib/{ => meta_operations}/telescope.mli (100%)
 create mode 100644 lib/parser/dune
 rename lib/{ => parser}/lexer.mll (100%)
 rename lib/{ => parser}/parser.mly (100%)

diff --git a/lib/dune b/lib/dune
index 748b41c6..123de639 100644
--- a/lib/dune
+++ b/lib/dune
@@ -1,7 +1,4 @@
-(menhir
- (modules parser))
-
-(ocamllex lexer)
+(include_subdirs unqualified)
 
 (library
  (name catt)
diff --git a/lib/elaborate.ml b/lib/elaboration/elaborate.ml
similarity index 100%
rename from lib/elaborate.ml
rename to lib/elaboration/elaborate.ml
diff --git a/lib/elaborate.mli b/lib/elaboration/elaborate.mli
similarity index 100%
rename from lib/elaborate.mli
rename to lib/elaboration/elaborate.mli
diff --git a/lib/translate_raw.ml b/lib/elaboration/translate_raw.ml
similarity index 100%
rename from lib/translate_raw.ml
rename to lib/elaboration/translate_raw.ml
diff --git a/lib/translate_raw.mli b/lib/elaboration/translate_raw.mli
similarity index 100%
rename from lib/translate_raw.mli
rename to lib/elaboration/translate_raw.mli
diff --git a/lib/equality.ml b/lib/internals/equality.ml
similarity index 100%
rename from lib/equality.ml
rename to lib/internals/equality.ml
diff --git a/lib/equality.mli b/lib/internals/equality.mli
similarity index 100%
rename from lib/equality.mli
rename to lib/internals/equality.mli
diff --git a/lib/kernel.ml b/lib/internals/kernel.ml
similarity index 100%
rename from lib/kernel.ml
rename to lib/internals/kernel.ml
diff --git a/lib/kernel.mli b/lib/internals/kernel.mli
similarity index 100%
rename from lib/kernel.mli
rename to lib/internals/kernel.mli
diff --git a/lib/printing.ml b/lib/internals/printing.ml
similarity index 100%
rename from lib/printing.ml
rename to lib/internals/printing.ml
diff --git a/lib/printing.mli b/lib/internals/printing.mli
similarity index 100%
rename from lib/printing.mli
rename to lib/internals/printing.mli
diff --git a/lib/unchecked.ml b/lib/internals/unchecked.ml
similarity index 100%
rename from lib/unchecked.ml
rename to lib/internals/unchecked.ml
diff --git a/lib/unchecked.mli b/lib/internals/unchecked.mli
similarity index 100%
rename from lib/unchecked.mli
rename to lib/internals/unchecked.mli
diff --git a/lib/unchecked_types.ml b/lib/internals/unchecked_types.ml
similarity index 100%
rename from lib/unchecked_types.ml
rename to lib/internals/unchecked_types.ml
diff --git a/lib/unchecked_types.mli b/lib/internals/unchecked_types.mli
similarity index 100%
rename from lib/unchecked_types.mli
rename to lib/internals/unchecked_types.mli
diff --git a/lib/command.ml b/lib/lib/command.ml
similarity index 100%
rename from lib/command.ml
rename to lib/lib/command.ml
diff --git a/lib/command.mli b/lib/lib/command.mli
similarity index 100%
rename from lib/command.mli
rename to lib/lib/command.mli
diff --git a/lib/common.ml b/lib/lib/common.ml
similarity index 100%
rename from lib/common.ml
rename to lib/lib/common.ml
diff --git a/lib/common.mli b/lib/lib/common.mli
similarity index 100%
rename from lib/common.mli
rename to lib/lib/common.mli
diff --git a/lib/environment.ml b/lib/lib/environment.ml
similarity index 100%
rename from lib/environment.ml
rename to lib/lib/environment.ml
diff --git a/lib/environment.mli b/lib/lib/environment.mli
similarity index 100%
rename from lib/environment.mli
rename to lib/lib/environment.mli
diff --git a/lib/error.ml b/lib/lib/error.ml
similarity index 100%
rename from lib/error.ml
rename to lib/lib/error.ml
diff --git a/lib/error.mli b/lib/lib/error.mli
similarity index 100%
rename from lib/error.mli
rename to lib/lib/error.mli
diff --git a/lib/io.ml b/lib/lib/io.ml
similarity index 100%
rename from lib/io.ml
rename to lib/lib/io.ml
diff --git a/lib/io.mli b/lib/lib/io.mli
similarity index 100%
rename from lib/io.mli
rename to lib/lib/io.mli
diff --git a/lib/meta.ml b/lib/lib/meta.ml
similarity index 100%
rename from lib/meta.ml
rename to lib/lib/meta.ml
diff --git a/lib/meta.mli b/lib/lib/meta.mli
similarity index 100%
rename from lib/meta.mli
rename to lib/lib/meta.mli
diff --git a/lib/raw.ml b/lib/lib/raw.ml
similarity index 100%
rename from lib/raw.ml
rename to lib/lib/raw.ml
diff --git a/lib/raw.mli b/lib/lib/raw.mli
similarity index 100%
rename from lib/raw.mli
rename to lib/lib/raw.mli
diff --git a/lib/raw_types.mli b/lib/lib/raw_types.mli
similarity index 100%
rename from lib/raw_types.mli
rename to lib/lib/raw_types.mli
diff --git a/lib/settings.ml b/lib/lib/settings.ml
similarity index 100%
rename from lib/settings.ml
rename to lib/lib/settings.ml
diff --git a/lib/settings.mli b/lib/lib/settings.mli
similarity index 100%
rename from lib/settings.mli
rename to lib/lib/settings.mli
diff --git a/lib/std.ml b/lib/lib/std.ml
similarity index 100%
rename from lib/std.ml
rename to lib/lib/std.ml
diff --git a/lib/std.mli b/lib/lib/std.mli
similarity index 100%
rename from lib/std.mli
rename to lib/lib/std.mli
diff --git a/lib/builtin.ml b/lib/meta_operations/builtin.ml
similarity index 100%
rename from lib/builtin.ml
rename to lib/meta_operations/builtin.ml
diff --git a/lib/builtin.mli b/lib/meta_operations/builtin.mli
similarity index 100%
rename from lib/builtin.mli
rename to lib/meta_operations/builtin.mli
diff --git a/lib/cones.ml b/lib/meta_operations/cones.ml
similarity index 100%
rename from lib/cones.ml
rename to lib/meta_operations/cones.ml
diff --git a/lib/cones.mli b/lib/meta_operations/cones.mli
similarity index 100%
rename from lib/cones.mli
rename to lib/meta_operations/cones.mli
diff --git a/lib/construct.ml b/lib/meta_operations/construct.ml
similarity index 100%
rename from lib/construct.ml
rename to lib/meta_operations/construct.ml
diff --git a/lib/construct.mli b/lib/meta_operations/construct.mli
similarity index 100%
rename from lib/construct.mli
rename to lib/meta_operations/construct.mli
diff --git a/lib/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
similarity index 100%
rename from lib/cubical_composite.ml
rename to lib/meta_operations/cubical_composite.ml
diff --git a/lib/cubical_composite.mli b/lib/meta_operations/cubical_composite.mli
similarity index 100%
rename from lib/cubical_composite.mli
rename to lib/meta_operations/cubical_composite.mli
diff --git a/lib/cylinders.ml b/lib/meta_operations/cylinders.ml
similarity index 100%
rename from lib/cylinders.ml
rename to lib/meta_operations/cylinders.ml
diff --git a/lib/cylinders.mli b/lib/meta_operations/cylinders.mli
similarity index 100%
rename from lib/cylinders.mli
rename to lib/meta_operations/cylinders.mli
diff --git a/lib/eh.ml b/lib/meta_operations/eh.ml
similarity index 100%
rename from lib/eh.ml
rename to lib/meta_operations/eh.ml
diff --git a/lib/eh.mli b/lib/meta_operations/eh.mli
similarity index 100%
rename from lib/eh.mli
rename to lib/meta_operations/eh.mli
diff --git a/lib/functorialisation.ml b/lib/meta_operations/functorialisation.ml
similarity index 100%
rename from lib/functorialisation.ml
rename to lib/meta_operations/functorialisation.ml
diff --git a/lib/functorialisation.mli b/lib/meta_operations/functorialisation.mli
similarity index 100%
rename from lib/functorialisation.mli
rename to lib/meta_operations/functorialisation.mli
diff --git a/lib/inverse.ml b/lib/meta_operations/inverse.ml
similarity index 100%
rename from lib/inverse.ml
rename to lib/meta_operations/inverse.ml
diff --git a/lib/inverse.mli b/lib/meta_operations/inverse.mli
similarity index 100%
rename from lib/inverse.mli
rename to lib/meta_operations/inverse.mli
diff --git a/lib/opposite.ml b/lib/meta_operations/opposite.ml
similarity index 100%
rename from lib/opposite.ml
rename to lib/meta_operations/opposite.ml
diff --git a/lib/opposite.mli b/lib/meta_operations/opposite.mli
similarity index 100%
rename from lib/opposite.mli
rename to lib/meta_operations/opposite.mli
diff --git a/lib/padding.ml b/lib/meta_operations/padding.ml
similarity index 100%
rename from lib/padding.ml
rename to lib/meta_operations/padding.ml
diff --git a/lib/padding.mli b/lib/meta_operations/padding.mli
similarity index 100%
rename from lib/padding.mli
rename to lib/meta_operations/padding.mli
diff --git a/lib/ps_reduction.ml b/lib/meta_operations/ps_reduction.ml
similarity index 100%
rename from lib/ps_reduction.ml
rename to lib/meta_operations/ps_reduction.ml
diff --git a/lib/ps_reduction.mli b/lib/meta_operations/ps_reduction.mli
similarity index 100%
rename from lib/ps_reduction.mli
rename to lib/meta_operations/ps_reduction.mli
diff --git a/lib/suspension.ml b/lib/meta_operations/suspension.ml
similarity index 100%
rename from lib/suspension.ml
rename to lib/meta_operations/suspension.ml
diff --git a/lib/suspension.mli b/lib/meta_operations/suspension.mli
similarity index 100%
rename from lib/suspension.mli
rename to lib/meta_operations/suspension.mli
diff --git a/lib/telescope.ml b/lib/meta_operations/telescope.ml
similarity index 100%
rename from lib/telescope.ml
rename to lib/meta_operations/telescope.ml
diff --git a/lib/telescope.mli b/lib/meta_operations/telescope.mli
similarity index 100%
rename from lib/telescope.mli
rename to lib/meta_operations/telescope.mli
diff --git a/lib/parser/dune b/lib/parser/dune
new file mode 100644
index 00000000..dd8f66f9
--- /dev/null
+++ b/lib/parser/dune
@@ -0,0 +1,4 @@
+(menhir
+ (modules parser))
+
+(ocamllex lexer)
diff --git a/lib/lexer.mll b/lib/parser/lexer.mll
similarity index 100%
rename from lib/lexer.mll
rename to lib/parser/lexer.mll
diff --git a/lib/parser.mly b/lib/parser/parser.mly
similarity index 100%
rename from lib/parser.mly
rename to lib/parser/parser.mly

From 187e7f5707aa066097601b13621d0a5d7080b56c Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 3 Oct 2025 17:45:48 +0200
Subject: [PATCH 18/30] [internals] refactor modules and signatures for
 unchecked syntax

---
 lib/dune                       |   2 +-
 lib/internals/display_maps.ml  |  88 +++++++++++++++++++++++++++
 lib/internals/display_maps.mli |  25 ++++++++
 lib/internals/equality.mli     |  14 +----
 lib/internals/kernel.ml        |  86 +++++++-------------------
 lib/internals/kernel.mli       |  95 ++---------------------------
 lib/internals/printing.mli     |  15 +----
 lib/internals/signatures.mli   | 106 +++++++++++++++++++++++++++++++++
 lib/internals/syntax.ml        |  44 ++++++++++++++
 lib/internals/syntax.mli       |  46 ++++++++++++++
 lib/internals/unchecked.ml     |  64 --------------------
 lib/internals/unchecked.mli    |  71 +---------------------
 12 files changed, 346 insertions(+), 310 deletions(-)
 create mode 100644 lib/internals/display_maps.ml
 create mode 100644 lib/internals/display_maps.mli
 create mode 100644 lib/internals/signatures.mli
 create mode 100644 lib/internals/syntax.ml
 create mode 100644 lib/internals/syntax.mli

diff --git a/lib/dune b/lib/dune
index 123de639..4a064f5f 100644
--- a/lib/dune
+++ b/lib/dune
@@ -3,7 +3,7 @@
 (library
  (name catt)
  (public_name catt)
- (modules_without_implementation raw_types)
+ (modules_without_implementation raw_types signatures)
  (libraries base)
  (instrumentation
   (backend landmarks --auto)))
diff --git a/lib/internals/display_maps.ml b/lib/internals/display_maps.ml
new file mode 100644
index 00000000..14b9947b
--- /dev/null
+++ b/lib/internals/display_maps.ml
@@ -0,0 +1,88 @@
+open Std
+open Common
+open Unchecked_types
+
+module DisplayMaps (CohT : sig
+  type t
+end) (TmT : sig
+  type t
+end) =
+struct
+  open Unchecked_types (CohT) (TmT)
+
+  module Make (Coh : sig
+    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
+    val check : ps -> ty -> pp_data -> CohT.t
+  end) (Tm : sig
+    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
+
+    val apply :
+      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
+      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
+      (pp_data -> pp_data) ->
+      TmT.t ->
+      TmT.t * Unchecked_types(CohT)(TmT).sub
+  end) =
+  struct
+    module U = Unchecked.Unchecked (CohT) (TmT)
+    module Unchecked = U.Make (Coh) (Tm)
+
+    let var_apply_sub v s =
+      match Unchecked.tm_apply_sub (Var v) s with
+      | Var v -> v
+      | _ ->
+          Error.fatal "image of a variable by a display map must be a variable"
+
+    (* Pullback of a substitution along a display map. Returns the resulting
+     * context with the right canonical inclusion. The left canonical inclusion is
+     *  the identity. *)
+    let rec pullback c1 sub c2 dm =
+      match (c2, dm) with
+      | [], [] -> (c1, [])
+      | (x, (_, expl)) :: ctx, (p, (Var y, _)) :: dm when x = y ->
+          let ctx, names = pullback c1 sub ctx dm in
+          (ctx, (x, (Unchecked.tm_apply_sub (Var p) sub, expl)) :: names)
+      | (x, (ty, expl)) :: ctx, (_ as dm) ->
+          let ctx, names = pullback c1 sub ctx dm in
+          let newvar = Var.fresh () in
+          let ty = Unchecked.ty_apply_sub ty names in
+          ((newvar, (ty, expl)) :: ctx, (x, (Var newvar, expl)) :: names)
+      | [], _ :: _ ->
+          Error.fatal
+            "wrong data for pullback: display map cannot be longer than the \
+             context"
+
+    (* Universal property of the pullback, gluing substitutions s1 and s2. Requires
+     * the inr canonical inclusion, the second context and the display map *)
+    let rec glue s1 s2 inr c2 dm =
+      match (s2, c2, dm) with
+      | [], [], [] -> s1
+      | (z, _) :: s2, (x, _) :: c2, (_, (Var y, _)) :: dm when x = y && x = z ->
+          let s = glue s1 s2 inr c2 dm in
+          s
+      | (z, (t, e)) :: s2, (x, _) :: c2, (_ as dm) when x = z ->
+          let s = glue s1 s2 inr c2 dm in
+          let var =
+            match Unchecked.tm_apply_sub (Var x) inr with
+            | Var x -> x
+            | _ -> assert false
+          in
+          (var, (t, e)) :: s
+      | _, [], _ :: _ ->
+          Error.fatal
+            "wrong data for pullback gluing: display map cannot be longer than \
+             the context"
+      | _, _, _ ->
+          Error.fatal
+            "wrong data pullback gluing: substitution must point to the context"
+
+    let pp_data_rename pp names =
+      let name, susp, func = pp in
+      let rec rename f =
+        match f with
+        | [] -> []
+        | (x, i) :: f -> (var_apply_sub x names, i) :: rename f
+      in
+      (name, susp, List.map rename func)
+  end
+end
diff --git a/lib/internals/display_maps.mli b/lib/internals/display_maps.mli
new file mode 100644
index 00000000..12fb0436
--- /dev/null
+++ b/lib/internals/display_maps.mli
@@ -0,0 +1,25 @@
+open Common
+open Unchecked_types
+
+module DisplayMaps (Coh : sig
+  type t
+end) (Tm : sig
+  type t
+end) : sig
+  open Unchecked_types(Coh)(Tm)
+  open Signatures.Signatures(Coh)(Tm)
+
+  module Make (_ : sig
+    val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
+    val check : ps -> ty -> pp_data -> Coh.t
+  end) (_ : sig
+    val develop : Tm.t -> Unchecked_types(Coh)(Tm).tm
+
+    val apply :
+      (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
+      (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
+      (pp_data -> pp_data) ->
+      Tm.t ->
+      Tm.t * Unchecked_types(Coh)(Tm).sub
+  end) : DisplayMapsS
+end
diff --git a/lib/internals/equality.mli b/lib/internals/equality.mli
index 922ac293..3803acf5 100644
--- a/lib/internals/equality.mli
+++ b/lib/internals/equality.mli
@@ -1,5 +1,6 @@
 open Common
 open Unchecked_types
+open Signatures
 
 module Equality (Coh : sig
   type t
@@ -7,6 +8,7 @@ end) (Tm : sig
   type t
 end) : sig
   open Unchecked_types(Coh)(Tm)
+  open Signatures(Coh)(Tm)
 
   module Make (_ : sig
     val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
@@ -28,15 +30,5 @@ end) : sig
       (pp_data -> pp_data) ->
       Tm.t ->
       Tm.t * Unchecked_types(Coh)(Tm).sub
-  end) : sig
-    val check_equal_ctx : ctx -> ctx -> unit
-    val check_equal_ps : ps -> ps -> unit
-    val check_equal_ty : ty -> ty -> unit
-    val check_equal_tm : tm -> tm -> unit
-    val check_equal_sub_ps : sub_ps -> sub_ps -> unit
-    val is_equal_ctx : ctx -> ctx -> bool
-    val is_equal_ps : ps -> ps -> bool
-    val is_equal_ty : ty -> ty -> bool
-    val is_equal_tm : tm -> tm -> bool
-  end
+  end) : EqualityS
 end
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index 12bbaa06..d36d7cae 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -1,9 +1,6 @@
 open Std
 open Common
 open Unchecked_types
-open Unchecked
-open Printing
-open Equality
 
 exception IsObj
 exception IsCoh
@@ -31,13 +28,10 @@ end = struct
   let src s = s.src
   let tgt s = s.tgt
 
-  open Unchecked (Coh) (Tm)
-  module Unchecked = Make (Coh) (Tm)
-  module Types = Unchecked_types (Coh) (Tm)
-  open Printing (Coh) (Tm) (Unchecked)
-  module Printing = Make (Coh) (Tm)
+  module Syntax = Syntax.Syntax (Coh) (Tm)
+  open Syntax.Make (Coh) (Tm)
 
-  let tbl : (Ctx.t * PS.t * Types.sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
+  let tbl : (Ctx.t * PS.t * sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
   let free_vars s = List.concat (List.map Tm.free_vars s.list)
 
   let check src s tgt =
@@ -102,13 +96,8 @@ and Ctx : sig
 end = struct
   type t = { c : (Var.t * Ty.t) list; unchecked : Unchecked_types(Coh)(Tm).ctx }
 
-  open Unchecked_types (Coh) (Tm)
-  module U = Unchecked (Coh) (Tm)
-  module Unchecked = U.Make (Coh) (Tm)
-  module P = Printing (Coh) (Tm) (Unchecked)
-  module Printing = P.Make (Coh) (Tm)
-  module E = Equality (Coh) (Tm)
-  module Equality = E.Make (Coh) (Tm)
+  module Syntax = Syntax.Syntax (Coh) (Tm)
+  open Syntax.Make (Coh) (Tm)
 
   let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
@@ -182,12 +171,8 @@ and PS : sig
 end = struct
   exception Invalid
 
-  module U = Unchecked (Coh) (Tm)
-  module Unchecked = U.Make (Coh) (Tm)
-  module P = Printing (Coh) (Tm) (Unchecked)
-  module Printing = P.Make (Coh) (Tm)
-  module E = Equality (Coh) (Tm)
-  module Equality = E.Make (Coh) (Tm)
+  module Syntax = Syntax.Syntax (Coh) (Tm)
+  open Syntax.Make (Coh) (Tm)
 
   (** A pasting scheme. *)
   type ps_derivation =
@@ -341,20 +326,15 @@ and Ty : sig
   val ctx : t -> Ctx.t
   val dim : t -> int
 end = struct
-  module Types = Unchecked_types (Coh) (Tm)
-  module U = Unchecked (Coh) (Tm)
-  module Unchecked = U.Make (Coh) (Tm)
-  module P = Printing (Coh) (Tm) (Unchecked)
-  module Printing = P.Make (Coh) (Tm)
-  module E = Equality (Coh) (Tm)
-  module Equality = E.Make (Coh) (Tm)
+  module Syntax = Syntax.Syntax (Coh) (Tm)
+  open Syntax.Make (Coh) (Tm)
 
   (** A type exepression. *)
   type expr = Obj | Arr of t * Tm.t * Tm.t
 
-  and t = { c : Ctx.t; e : expr; unchecked : Types.ty }
+  and t = { c : Ctx.t; e : expr; unchecked : ty }
 
-  let tbl : (Ctx.t * Types.ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
+  let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
   let is_obj t = t.e = Obj
 
   let retrieve_arrow ty =
@@ -466,28 +446,22 @@ and Tm : sig
 
   val is_equal : t -> t -> bool
 end = struct
-  module U = Unchecked (Coh) (Tm)
-  module Unchecked = U.Make (Coh) (Tm)
-  module Types = Unchecked_types (Coh) (Tm)
-  module Display_maps = Unchecked.Display_maps
-  module P = Printing (Coh) (Tm) (Unchecked)
-  module Printing = P.Make (Coh) (Tm)
-  module E = Equality (Coh) (Tm)
-  module Equality = E.Make (Coh) (Tm)
+  module Syntax = Syntax.Syntax (Coh) (Tm)
+  open Syntax.Make (Coh) (Tm)
 
   type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
 
   and t = {
     ty : Ty.t;
     e : expr;
-    unchecked : Types.tm;
-    mutable developped : Types.tm option;
+    unchecked : tm;
+    mutable developped : tm option;
     name : pp_data option;
   }
 
   let typ t = t.ty
   let ty t = Ty.forget t.ty
-  let tbl : (Ctx.t * Types.tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
+  let tbl : (Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
 
   let free_vars tm =
     let fvty = Ty.free_vars tm.ty in
@@ -665,24 +639,15 @@ end = struct
   type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
   type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
 
-  module Types = Unchecked_types (Coh) (Tm)
+  module Syntax = Syntax.Syntax (Coh) (Tm)
+  open Syntax.Make (Coh) (Tm)
 
-  let tbl : (ps * Types.ty, Coh.t) Hashtbl.t = Hashtbl.create 7829
-
-  let tbl_inv : (ps * Types.tm * Types.tm, Coh.t) Hashtbl.t =
-    Hashtbl.create 7829
-
-  let tbl_noninv : (ps * Types.tm * Types.tm, Coh.t) Hashtbl.t =
-    Hashtbl.create 7829
+  let tbl : (ps * ty, Coh.t) Hashtbl.t = Hashtbl.create 7829
+  let tbl_inv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
+  let tbl_noninv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
 
   exception NotAlgebraic
 
-  open Unchecked (Coh) (Tm)
-  module Unchecked = Make (Coh) (Tm)
-  module Display_maps = Unchecked.Display_maps
-  open Printing (Coh) (Tm) (Unchecked)
-  module Printing = Make (Coh) (Tm)
-
   let ps = function Inv (data, _) -> data.ps | NonInv (data, _) -> data.ps
 
   let ty = function
@@ -836,13 +801,8 @@ end = struct
     (check ps ty pp_data, db_sub)
 end
 
-module U = Unchecked (Coh) (Tm)
-module Unchecked = U.Make (Coh) (Tm)
-module Display_maps = Unchecked.Display_maps
-module P = Printing (Coh) (Tm) (Unchecked)
-module Printing = P.Make (Coh) (Tm)
-module E = Equality (Coh) (Tm)
-module Equality = E.Make (Coh) (Tm)
+module Syntax = Syntax.Syntax (Coh) (Tm)
+include Syntax.Make (Coh) (Tm)
 
 let check check_fn name =
   let v = 2 in
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index e4fd07d6..d72ebb8d 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,5 +1,6 @@
 open Common
 open Unchecked_types
+open Signatures
 
 module rec Coh : sig
   type t
@@ -97,95 +98,11 @@ module PS : sig
   val forget : t -> ps
 end
 
-module Unchecked : sig
-  type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
-
-  val dim_ctx : ctx -> int
-  val dim_ty : ty -> int
-  val dim_ps : ps -> int
-  val ps_to_ctx : ps -> ctx
-  val identity_ps : ps -> sub_ps
-  val tm_apply_sub : tm -> sub -> tm
-  val ty_apply_sub : ty -> sub -> ty
-  val sub_apply_sub : sub -> sub -> sub
-  val sub_ps_apply_sub : sub_ps -> sub -> sub_ps
-  val ty_apply_sub_ps : ty -> sub_ps -> ty
-  val tm_apply_sub_ps : tm -> sub_ps -> tm
-  val sub_ps_apply_sub_ps : sub_ps -> sub_ps -> sub_ps
-  val ty_rename : ty -> (Var.t * tm) list -> ty
-  val tm_rename : tm -> (Var.t * tm) list -> tm
-  val sub_ps_rename : sub_ps -> (Var.t * tm) list -> sub_ps
-  val ty_sub_preimage : ty -> sub -> ty
-  val db_levels : ctx -> ctx * (Var.t * (int * bool)) list * int
-  val db_level_sub : ctx -> sub
-  val db_level_sub_inv : ctx -> sub
-  val rename_ty : ty -> (Var.t * (int * bool)) list -> ty
-  val rename_tm : tm -> (Var.t * (int * bool)) list -> tm
-  val tm_contains_var : tm -> Var.t -> bool
-  val ty_contains_var : ty -> Var.t -> bool
-  val tm_contains_vars : tm -> Var.t list -> bool
-  val sub_ps_to_sub : sub_ps -> sub
-  val sub_to_sub_ps : sub -> sub_ps
-  val suspend_pp_data : pp_data -> pp_data
-  val suspend_ps : ps -> ps
-  val suspend_ty : ty -> ty
-  val suspend_tm : tm -> tm
-  val suspend_ctx : ctx -> ctx
-  val suspend_sub_ps : sub_ps -> sub_ps
-  val suspend_sub : sub -> sub
-  val ps_bdry : ps -> ps
-  val ps_src : ps -> sub_ps
-  val ps_tgt : ps -> sub_ps
-  val tm_sub_preimage : tm -> sub -> tm
-  val suspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
-  val opsuspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
-  val canonical_inclusions : ps list -> sub_ps list
-  val ps_compose : int -> ps -> ps -> ps * sub_ps * sub_ps
-  val pullback_up : int -> ps -> ps -> sub_ps -> sub_ps -> sub_ps
-  val ty_to_sub_ps : ty -> sub_ps
-  val coh_to_sub_ps : tm -> sub_ps
-  val sub_ps_to_sub_ps_bp : sub_ps -> sub_ps_bp
-  val wedge_sub_ps_bp : sub_ps_bp list -> sub_ps
-  val list_to_sub : tm list -> ctx -> sub
-  val list_to_db_level_sub : tm list -> (Var.t * tm) list
-  val identity : ctx -> sub
-  val disc : int -> ps
-  val disc_ctx : int -> ctx
-  val disc_type : int -> ty
-  val sphere : int -> ctx
-  val sphere_inc : int -> sub
-  val disc_src : int -> sub_ps
-  val disc_tgt : int -> sub_ps
-  val develop_tm : tm -> tm
-  val develop_ty : ty -> ty
-end
-
-module Printing : sig
-  val ps_to_string : ps -> string
-  val ty_to_string : ty -> string
-  val tm_to_string : tm -> string
-  val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
-  val ctx_to_string : ctx -> string
-  val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
-  val sub_to_string_debug : sub -> string
-  val meta_ctx_to_string : meta_ctx -> string
-  val pp_data_to_string : ?print_func:bool -> pp_data -> string
-  val full_name : pp_data -> string
-  val print_kolmogorov : tm -> string
-end
-
-module Equality : sig
-  val check_equal_ctx : ctx -> ctx -> unit
-  val check_equal_ps : ps -> ps -> unit
-  val check_equal_ty : ty -> ty -> unit
-  val check_equal_tm : tm -> tm -> unit
-end
-
-module Display_maps : sig
-  val var_apply_sub : Var.t -> sub -> Var.t
-  val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
-  val glue : sub -> sub -> sub -> ctx -> sub -> sub
-end
+open Signatures(Coh)(Tm)
+module Unchecked : UncheckedS
+module Printing : PrintingS
+module Equality : EqualityS
+module Display_maps : DisplayMapsS
 
 val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
 val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
diff --git a/lib/internals/printing.mli b/lib/internals/printing.mli
index 76ad0332..10666a0d 100644
--- a/lib/internals/printing.mli
+++ b/lib/internals/printing.mli
@@ -12,6 +12,7 @@ end) (_ : sig
     Unchecked_types(Coh)(Tm).tm
 end) : sig
   open Unchecked_types(Coh)(Tm)
+  open Signatures.Signatures(Coh)(Tm)
 
   module Make (_ : sig
     val to_string : ?unroll:bool -> Coh.t -> string
@@ -25,17 +26,5 @@ end) : sig
     val develop : Tm.t -> tm
     val ctx : Tm.t -> ctx
     val is_equal : Tm.t -> Tm.t -> bool
-  end) : sig
-    val ps_to_string : ps -> string
-    val ty_to_string : ty -> string
-    val tm_to_string : tm -> string
-    val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
-    val ctx_to_string : ctx -> string
-    val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
-    val sub_to_string_debug : sub -> string
-    val meta_ctx_to_string : meta_ctx -> string
-    val full_name : pp_data -> string
-    val pp_data_to_string : ?print_func:bool -> pp_data -> string
-    val print_kolmogorov : tm -> string
-  end
+  end) : PrintingS
 end
diff --git a/lib/internals/signatures.mli b/lib/internals/signatures.mli
new file mode 100644
index 00000000..b95cb324
--- /dev/null
+++ b/lib/internals/signatures.mli
@@ -0,0 +1,106 @@
+open Common
+open Unchecked_types
+
+module Signatures (Coh : sig
+  type t
+end) (Tm : sig
+  type t
+end) : sig
+  open Unchecked_types(Coh)(Tm)
+
+  module type UncheckedS = sig
+    type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
+
+    val dim_ctx : ctx -> int
+    val dim_ty : ty -> int
+    val dim_ps : ps -> int
+    val ps_to_ctx : ps -> ctx
+    val identity_ps : ps -> sub_ps
+    val tm_apply_sub : tm -> sub -> tm
+    val ty_apply_sub : ty -> sub -> ty
+    val sub_apply_sub : sub -> sub -> sub
+    val sub_ps_apply_sub : sub_ps -> sub -> sub_ps
+    val ty_apply_sub_ps : ty -> sub_ps -> ty
+    val tm_apply_sub_ps : tm -> sub_ps -> tm
+    val sub_ps_apply_sub_ps : sub_ps -> sub_ps -> sub_ps
+    val ty_rename : ty -> (Var.t * tm) list -> ty
+    val tm_rename : tm -> (Var.t * tm) list -> tm
+    val sub_ps_rename : sub_ps -> (Var.t * tm) list -> sub_ps
+    val ty_sub_preimage : ty -> sub -> ty
+    val db_levels : ctx -> ctx * (Var.t * (int * bool)) list * int
+    val db_level_sub : ctx -> sub
+    val db_level_sub_inv : ctx -> sub
+    val rename_ty : ty -> (Var.t * (int * bool)) list -> ty
+    val rename_tm : tm -> (Var.t * (int * bool)) list -> tm
+    val tm_contains_var : tm -> Var.t -> bool
+    val ty_contains_var : ty -> Var.t -> bool
+    val tm_contains_vars : tm -> Var.t list -> bool
+    val sub_ps_to_sub : sub_ps -> sub
+    val sub_to_sub_ps : sub -> sub_ps
+    val suspend_pp_data : pp_data -> pp_data
+    val suspend_ps : ps -> ps
+    val suspend_ty : ty -> ty
+    val suspend_tm : tm -> tm
+    val suspend_ctx : ctx -> ctx
+    val suspend_sub_ps : sub_ps -> sub_ps
+    val suspend_sub : sub -> sub
+    val ps_bdry : ps -> ps
+    val ps_src : ps -> sub_ps
+    val ps_tgt : ps -> sub_ps
+    val tm_sub_preimage : tm -> sub -> tm
+    val suspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
+    val opsuspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
+    val canonical_inclusions : ps list -> sub_ps list
+    val ty_to_sub_ps : ty -> sub_ps
+    val coh_to_sub_ps : tm -> sub_ps
+    val ps_compose : int -> ps -> ps -> ps * sub_ps * sub_ps
+    val pullback_up : int -> ps -> ps -> sub_ps -> sub_ps -> sub_ps
+    val sub_ps_to_sub_ps_bp : sub_ps -> sub_ps_bp
+    val wedge_sub_ps_bp : sub_ps_bp list -> sub_ps
+    val list_to_sub : tm list -> ctx -> sub
+    val list_to_db_level_sub : tm list -> (Var.t * tm) list
+    val identity : ctx -> sub
+    val disc : int -> ps
+    val disc_ctx : int -> ctx
+    val disc_type : int -> ty
+    val sphere : int -> ctx
+    val sphere_inc : int -> sub
+    val disc_src : int -> sub_ps
+    val disc_tgt : int -> sub_ps
+    val develop_tm : tm -> tm
+    val develop_ty : ty -> ty
+  end
+
+  module type PrintingS = sig
+    val ps_to_string : ps -> string
+    val ty_to_string : ty -> string
+    val tm_to_string : tm -> string
+    val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
+    val ctx_to_string : ctx -> string
+    val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
+    val sub_to_string_debug : sub -> string
+    val meta_ctx_to_string : meta_ctx -> string
+    val full_name : pp_data -> string
+    val pp_data_to_string : ?print_func:bool -> pp_data -> string
+    val print_kolmogorov : tm -> string
+  end
+
+  module type EqualityS = sig
+    val check_equal_ctx : ctx -> ctx -> unit
+    val check_equal_ps : ps -> ps -> unit
+    val check_equal_ty : ty -> ty -> unit
+    val check_equal_tm : tm -> tm -> unit
+    val check_equal_sub_ps : sub_ps -> sub_ps -> unit
+    val is_equal_ctx : ctx -> ctx -> bool
+    val is_equal_ps : ps -> ps -> bool
+    val is_equal_ty : ty -> ty -> bool
+    val is_equal_tm : tm -> tm -> bool
+  end
+
+  module type DisplayMapsS = sig
+    val var_apply_sub : Var.t -> sub -> Var.t
+    val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
+    val glue : sub -> sub -> sub -> ctx -> sub -> sub
+    val pp_data_rename : pp_data -> sub -> pp_data
+  end
+end
diff --git a/lib/internals/syntax.ml b/lib/internals/syntax.ml
new file mode 100644
index 00000000..c619992b
--- /dev/null
+++ b/lib/internals/syntax.ml
@@ -0,0 +1,44 @@
+open Common
+open Unchecked_types
+
+module Syntax (CohT : sig
+  type t
+end) (TmT : sig
+  type t
+end) =
+struct
+  open Unchecked_types (CohT) (TmT)
+
+  module Make (Coh : sig
+    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
+    val check : ps -> ty -> pp_data -> CohT.t
+    val to_string : ?unroll:bool -> CohT.t -> string
+    val func_data : CohT.t -> (Var.t * int) list list
+    val is_equal : CohT.t -> CohT.t -> bool
+  end) (Tm : sig
+    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
+    val func_data : TmT.t -> (Var.t * int) list list option
+    val name : TmT.t -> string option
+    val full_name : TmT.t -> string option
+    val ctx : TmT.t -> ctx
+    val is_equal : TmT.t -> TmT.t -> bool
+
+    val apply :
+      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
+      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
+      (pp_data -> pp_data) ->
+      TmT.t ->
+      TmT.t * Unchecked_types(CohT)(TmT).sub
+  end) =
+  struct
+    include Unchecked_types (CohT) (TmT)
+    module U = Unchecked.Unchecked (CohT) (TmT)
+    module Unchecked = U.Make (Coh) (Tm)
+    module D = Display_maps.DisplayMaps (CohT) (TmT)
+    module Display_maps = D.Make (Coh) (Tm)
+    module P = Printing.Printing (CohT) (TmT) (Unchecked)
+    module Printing = P.Make (Coh) (Tm)
+    module E = Equality.Equality (CohT) (TmT)
+    module Equality = E.Make (Coh) (Tm)
+  end
+end
diff --git a/lib/internals/syntax.mli b/lib/internals/syntax.mli
new file mode 100644
index 00000000..4374d1a3
--- /dev/null
+++ b/lib/internals/syntax.mli
@@ -0,0 +1,46 @@
+open Unchecked_types
+open Signatures
+open Common
+
+module Syntax : functor
+  (CohT : sig
+     type t
+   end)
+  (TmT : sig
+     type t
+   end)
+  -> sig
+  open Unchecked_types(CohT)(TmT)
+  open Signatures(CohT)(TmT)
+
+  module Make : functor
+    (_ : sig
+       val forget : CohT.t -> ps * ty * pp_data
+       val check : ps -> ty -> pp_data -> CohT.t
+       val to_string : ?unroll:bool -> CohT.t -> string
+       val func_data : CohT.t -> (Var.t * int) list list
+       val is_equal : CohT.t -> CohT.t -> bool
+     end)
+    (_ : sig
+       val develop : TmT.t -> tm
+       val func_data : TmT.t -> (Var.t * int) list list option
+       val name : TmT.t -> string option
+       val full_name : TmT.t -> string option
+       val ctx : TmT.t -> ctx
+       val is_equal : TmT.t -> TmT.t -> bool
+
+       val apply :
+         (ctx -> ctx) ->
+         (tm -> tm) ->
+         (pp_data -> pp_data) ->
+         TmT.t ->
+         TmT.t * sub
+     end)
+    -> sig
+    include module type of Unchecked_types (CohT) (TmT)
+    module Unchecked : UncheckedS
+    module Display_maps : DisplayMapsS
+    module Printing : PrintingS
+    module Equality : EqualityS
+  end
+end
diff --git a/lib/internals/unchecked.ml b/lib/internals/unchecked.ml
index 0d59100e..9c899459 100644
--- a/lib/internals/unchecked.ml
+++ b/lib/internals/unchecked.ml
@@ -494,69 +494,5 @@ struct
       | Obj -> Obj
       | Meta_ty i -> Meta_ty i
       | Arr (a, t, u) -> Arr (develop_ty a, develop_tm t, develop_tm u)
-
-    module Display_maps = struct
-      (* Construction related to display maps, i.e. var to var substitutions *)
-      let var_apply_sub v s =
-        match tm_apply_sub (Var v) s with
-        | Var v -> v
-        | _ ->
-            Error.fatal
-              "image of a variable by a display map must be a variable"
-
-      (* Pullback of a substitution along a display map. Returns the resulting
-         * context with the right canonical inclusion. The left canonical inclusion is
-         *  the identity. *)
-      let rec pullback c1 sub c2 dm =
-        match (c2, dm) with
-        | [], [] -> (c1, [])
-        | (x, (_, expl)) :: ctx, (p, (Var y, _)) :: dm when x = y ->
-            let ctx, names = pullback c1 sub ctx dm in
-            (ctx, (x, (tm_apply_sub (Var p) sub, expl)) :: names)
-        | (x, (ty, expl)) :: ctx, (_ as dm) ->
-            let ctx, names = pullback c1 sub ctx dm in
-            let newvar = Var.fresh () in
-            let ty = ty_apply_sub ty names in
-            ((newvar, (ty, expl)) :: ctx, (x, (Var newvar, expl)) :: names)
-        | [], _ :: _ ->
-            Error.fatal
-              "wrong data for pullback: display map cannot be longer than the \
-               context"
-
-      (* Universal property of the pullback, gluing substitutions s1 and s2. Requires
-         * the inr canonical inclusion, the second context and the display map *)
-      let rec glue s1 s2 inr c2 dm =
-        match (s2, c2, dm) with
-        | [], [], [] -> s1
-        | (z, _) :: s2, (x, _) :: c2, (_, (Var y, _)) :: dm when x = y && x = z
-          ->
-            let s = glue s1 s2 inr c2 dm in
-            s
-        | (z, (t, e)) :: s2, (x, _) :: c2, (_ as dm) when x = z ->
-            let s = glue s1 s2 inr c2 dm in
-            let var =
-              match tm_apply_sub (Var x) inr with
-              | Var x -> x
-              | _ -> assert false
-            in
-            (var, (t, e)) :: s
-        | _, [], _ :: _ ->
-            Error.fatal
-              "wrong data for pullback gluing: display map cannot be longer \
-               than the context"
-        | _, _, _ ->
-            Error.fatal
-              "wrong data pullback gluing: substitution must point to the \
-               context"
-
-      let pp_data_rename pp names =
-        let name, susp, func = pp in
-        let rec rename f =
-          match f with
-          | [] -> []
-          | (x, i) :: f -> (var_apply_sub x names, i) :: rename f
-        in
-        (name, susp, List.map rename func)
-    end
   end
 end
diff --git a/lib/internals/unchecked.mli b/lib/internals/unchecked.mli
index dbf3967b..73085bef 100644
--- a/lib/internals/unchecked.mli
+++ b/lib/internals/unchecked.mli
@@ -7,6 +7,7 @@ end) (Tm : sig
   type t
 end) : sig
   open Unchecked_types(Coh)(Tm)
+  open Signatures.Signatures(Coh)(Tm)
 
   module Make (_ : sig
     val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
@@ -20,73 +21,5 @@ end) : sig
       (pp_data -> pp_data) ->
       Tm.t ->
       Tm.t * Unchecked_types(Coh)(Tm).sub
-  end) : sig
-    type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
-
-    val dim_ctx : ctx -> int
-    val dim_ty : ty -> int
-    val dim_ps : ps -> int
-    val ps_to_ctx : ps -> ctx
-    val identity_ps : ps -> sub_ps
-    val tm_apply_sub : tm -> sub -> tm
-    val ty_apply_sub : ty -> sub -> ty
-    val sub_apply_sub : sub -> sub -> sub
-    val sub_ps_apply_sub : sub_ps -> sub -> sub_ps
-    val ty_apply_sub_ps : ty -> sub_ps -> ty
-    val tm_apply_sub_ps : tm -> sub_ps -> tm
-    val sub_ps_apply_sub_ps : sub_ps -> sub_ps -> sub_ps
-    val ty_rename : ty -> (Var.t * tm) list -> ty
-    val tm_rename : tm -> (Var.t * tm) list -> tm
-    val sub_ps_rename : sub_ps -> (Var.t * tm) list -> sub_ps
-    val ty_sub_preimage : ty -> sub -> ty
-    val db_levels : ctx -> ctx * (Var.t * (int * bool)) list * int
-    val db_level_sub : ctx -> sub
-    val db_level_sub_inv : ctx -> sub
-    val rename_ty : ty -> (Var.t * (int * bool)) list -> ty
-    val rename_tm : tm -> (Var.t * (int * bool)) list -> tm
-    val tm_contains_var : tm -> Var.t -> bool
-    val ty_contains_var : ty -> Var.t -> bool
-    val tm_contains_vars : tm -> Var.t list -> bool
-    val sub_ps_to_sub : sub_ps -> sub
-    val sub_to_sub_ps : sub -> sub_ps
-    val suspend_pp_data : pp_data -> pp_data
-    val suspend_ps : ps -> ps
-    val suspend_ty : ty -> ty
-    val suspend_tm : tm -> tm
-    val suspend_ctx : ctx -> ctx
-    val suspend_sub_ps : sub_ps -> sub_ps
-    val suspend_sub : sub -> sub
-    val ps_bdry : ps -> ps
-    val ps_src : ps -> sub_ps
-    val ps_tgt : ps -> sub_ps
-    val tm_sub_preimage : tm -> sub -> tm
-    val suspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
-    val opsuspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
-    val canonical_inclusions : ps list -> sub_ps list
-    val ty_to_sub_ps : ty -> sub_ps
-    val coh_to_sub_ps : tm -> sub_ps
-    val ps_compose : int -> ps -> ps -> ps * sub_ps * sub_ps
-    val pullback_up : int -> ps -> ps -> sub_ps -> sub_ps -> sub_ps
-    val sub_ps_to_sub_ps_bp : sub_ps -> sub_ps_bp
-    val wedge_sub_ps_bp : sub_ps_bp list -> sub_ps
-    val list_to_sub : tm list -> ctx -> sub
-    val list_to_db_level_sub : tm list -> (Var.t * tm) list
-    val identity : ctx -> sub
-    val disc : int -> ps
-    val disc_ctx : int -> ctx
-    val disc_type : int -> ty
-    val sphere : int -> ctx
-    val sphere_inc : int -> sub
-    val disc_src : int -> sub_ps
-    val disc_tgt : int -> sub_ps
-    val develop_tm : tm -> tm
-    val develop_ty : ty -> ty
-
-    module Display_maps : sig
-      val var_apply_sub : Var.t -> sub -> Var.t
-      val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
-      val glue : sub -> sub -> sub -> ctx -> sub -> sub
-      val pp_data_rename : pp_data -> sub -> pp_data
-    end
-  end
+  end) : UncheckedS
 end

From feb17dc753d71f4c36884d6fca9bcfa4796937ea Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 3 Oct 2025 18:01:40 +0200
Subject: [PATCH 19/30] [internals] imrpove kernel API

---
 lib/elaboration/elaborate.ml              |  1 -
 lib/elaboration/elaborate.mli             |  1 -
 lib/elaboration/translate_raw.ml          |  1 -
 lib/elaboration/translate_raw.mli         |  1 -
 lib/internals/kernel.mli                  | 13 +++++--------
 lib/lib/command.ml                        |  1 -
 lib/lib/command.mli                       |  1 -
 lib/lib/environment.ml                    |  1 -
 lib/lib/environment.mli                   |  1 -
 lib/lib/meta.ml                           |  1 -
 lib/lib/meta.mli                          |  1 -
 lib/meta_operations/builtin.ml            |  1 -
 lib/meta_operations/builtin.mli           |  1 -
 lib/meta_operations/cones.ml              |  1 -
 lib/meta_operations/construct.ml          |  1 -
 lib/meta_operations/construct.mli         |  1 -
 lib/meta_operations/cubical_composite.ml  |  1 -
 lib/meta_operations/cylinders.ml          |  1 -
 lib/meta_operations/eh.ml                 |  1 -
 lib/meta_operations/functorialisation.ml  |  1 -
 lib/meta_operations/functorialisation.mli |  1 -
 lib/meta_operations/inverse.ml            |  1 -
 lib/meta_operations/inverse.mli           |  1 -
 lib/meta_operations/opposite.ml           |  1 -
 lib/meta_operations/opposite.mli          |  1 -
 lib/meta_operations/padding.ml            |  1 -
 lib/meta_operations/padding.mli           |  1 -
 lib/meta_operations/ps_reduction.ml       |  1 -
 lib/meta_operations/ps_reduction.mli      |  1 -
 lib/meta_operations/suspension.mli        |  1 -
 lib/meta_operations/telescope.ml          |  1 -
 lib/meta_operations/telescope.mli         |  1 -
 rocq_plugin/src/export.ml                 |  1 -
 33 files changed, 5 insertions(+), 40 deletions(-)

diff --git a/lib/elaboration/elaborate.ml b/lib/elaboration/elaborate.ml
index c464be0f..9f7d8992 100644
--- a/lib/elaboration/elaborate.ml
+++ b/lib/elaboration/elaborate.ml
@@ -1,7 +1,6 @@
 open Std
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 exception NotUnifiable of string * string
 
diff --git a/lib/elaboration/elaborate.mli b/lib/elaboration/elaborate.mli
index 322f9bda..48e089ac 100644
--- a/lib/elaboration/elaborate.mli
+++ b/lib/elaboration/elaborate.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 open Raw_types
 
 val ctx : (Var.t * tyR) list -> ctx
diff --git a/lib/elaboration/translate_raw.ml b/lib/elaboration/translate_raw.ml
index d1ce4f3f..43482831 100644
--- a/lib/elaboration/translate_raw.ml
+++ b/lib/elaboration/translate_raw.ml
@@ -1,5 +1,4 @@
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 open Raw_types
 
 exception WrongNumberOfArguments
diff --git a/lib/elaboration/translate_raw.mli b/lib/elaboration/translate_raw.mli
index 8761349f..f59abe0b 100644
--- a/lib/elaboration/translate_raw.mli
+++ b/lib/elaboration/translate_raw.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 open Raw_types
 
 val tm : tmR -> tm * meta_ctx
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index d72ebb8d..aa1c4aa7 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,17 +1,18 @@
 open Common
 open Unchecked_types
-open Signatures
 
 module rec Coh : sig
   type t
 
   val forget : t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
+  val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
   val is_inv : t -> bool
   val to_string : ?unroll:bool -> t -> string
   val dim : t -> int
   val src : t -> Unchecked_types(Coh)(Tm).tm
   val tgt : t -> Unchecked_types(Coh)(Tm).tm
+  val check : ps -> Unchecked_types(Coh)(Tm).ty -> pp_data -> t
 
   val check_noninv :
     ps ->
@@ -72,6 +73,7 @@ and Tm : sig
   val develop : t -> Unchecked_types(Coh)(Tm).tm
   val pp_data : t -> pp_data option
   val to_string : t -> string
+  val is_equal : t -> t -> bool
 
   val apply :
     (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
@@ -81,7 +83,8 @@ and Tm : sig
     t * Unchecked_types(Coh)(Tm).sub
 end
 
-open Unchecked_types(Coh)(Tm)
+open Syntax.Syntax(Coh)(Tm)
+include module type of Make (Coh) (Tm)
 
 module Ctx : sig
   type t
@@ -98,12 +101,6 @@ module PS : sig
   val forget : t -> ps
 end
 
-open Signatures(Coh)(Tm)
-module Unchecked : UncheckedS
-module Printing : PrintingS
-module Equality : EqualityS
-module Display_maps : DisplayMapsS
-
 val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
 val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
 val check_coh : ps -> ty -> pp_data -> Coh.t
diff --git a/lib/lib/command.ml b/lib/lib/command.ml
index bd3367a7..37f5a31b 100644
--- a/lib/lib/command.ml
+++ b/lib/lib/command.ml
@@ -1,7 +1,6 @@
 open Common
 open Kernel
 open Raw_types
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 exception UnknownOption of string
 exception NotAnInt of string
diff --git a/lib/lib/command.mli b/lib/lib/command.mli
index ba22549b..13cc143f 100644
--- a/lib/lib/command.mli
+++ b/lib/lib/command.mli
@@ -1,7 +1,6 @@
 open Common
 open Kernel
 open Raw_types
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 type cmd =
   | Coh of Var.t * (Var.t * tyR) list * tyR
diff --git a/lib/lib/environment.ml b/lib/lib/environment.ml
index 2f94ba27..39ef59dc 100644
--- a/lib/lib/environment.ml
+++ b/lib/lib/environment.ml
@@ -1,7 +1,6 @@
 open Common
 open Raw_types
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 type value = Coh of Coh.t | Tm of Tm.t
 
diff --git a/lib/lib/environment.mli b/lib/lib/environment.mli
index e03b7d80..fe301508 100644
--- a/lib/lib/environment.mli
+++ b/lib/lib/environment.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 type value = Coh of Coh.t | Tm of Tm.t
 type t
diff --git a/lib/lib/meta.ml b/lib/lib/meta.ml
index 09e7e56d..8ed27c01 100644
--- a/lib/lib/meta.ml
+++ b/lib/lib/meta.ml
@@ -1,5 +1,4 @@
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let meta_namer_ty = ref 0
 let meta_namer_tm = ref 0
diff --git a/lib/lib/meta.mli b/lib/lib/meta.mli
index 36689957..8d4f7cd6 100644
--- a/lib/lib/meta.mli
+++ b/lib/lib/meta.mli
@@ -1,5 +1,4 @@
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val new_ty : unit -> ty
 val new_tm : unit -> tm * (int * ty)
diff --git a/lib/meta_operations/builtin.ml b/lib/meta_operations/builtin.ml
index 8d0f3c4a..6dee75f6 100644
--- a/lib/meta_operations/builtin.ml
+++ b/lib/meta_operations/builtin.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 module Memo = struct
   let tbl = Hashtbl.create 97
diff --git a/lib/meta_operations/builtin.mli b/lib/meta_operations/builtin.mli
index ada2ed3e..8624cc6b 100644
--- a/lib/meta_operations/builtin.mli
+++ b/lib/meta_operations/builtin.mli
@@ -1,7 +1,6 @@
 open Raw_types
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 module Comp : sig
   val tree : int -> ps
diff --git a/lib/meta_operations/cones.ml b/lib/meta_operations/cones.ml
index 4177cf5f..2e68f51e 100644
--- a/lib/meta_operations/cones.ml
+++ b/lib/meta_operations/cones.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let wcomp = Construct.wcomp
 
diff --git a/lib/meta_operations/construct.ml b/lib/meta_operations/construct.ml
index 206a4eba..91173f42 100644
--- a/lib/meta_operations/construct.ml
+++ b/lib/meta_operations/construct.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let to_tm (tm, _) = tm
 let to_ty (_, ty) = ty
diff --git a/lib/meta_operations/construct.mli b/lib/meta_operations/construct.mli
index d7db2a2b..1b5a29c0 100644
--- a/lib/meta_operations/construct.mli
+++ b/lib/meta_operations/construct.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val to_tm : constr -> tm
 val to_ty : constr -> ty
diff --git a/lib/meta_operations/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
index 5801e05f..0e539424 100644
--- a/lib/meta_operations/cubical_composite.ml
+++ b/lib/meta_operations/cubical_composite.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 module F = Functorialisation
 
 module LinearComp = struct
diff --git a/lib/meta_operations/cylinders.ml b/lib/meta_operations/cylinders.ml
index 65a0883a..4e9b69a0 100644
--- a/lib/meta_operations/cylinders.ml
+++ b/lib/meta_operations/cylinders.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let wcomp = Construct.wcomp
 
diff --git a/lib/meta_operations/eh.ml b/lib/meta_operations/eh.ml
index 1ed77466..d1c476d0 100644
--- a/lib/meta_operations/eh.ml
+++ b/lib/meta_operations/eh.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 module type EHArgsS = sig
   val n : int
diff --git a/lib/meta_operations/functorialisation.ml b/lib/meta_operations/functorialisation.ml
index b2363de5..e7f77a5a 100644
--- a/lib/meta_operations/functorialisation.ml
+++ b/lib/meta_operations/functorialisation.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 exception FunctorialiseMeta
 exception NotClosed
diff --git a/lib/meta_operations/functorialisation.mli b/lib/meta_operations/functorialisation.mli
index fca2ed0c..f59398be 100644
--- a/lib/meta_operations/functorialisation.mli
+++ b/lib/meta_operations/functorialisation.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val coh_depth1 : (Coh.t -> Var.t list -> Tm.t) ref
 val preimage : ctx -> sub_ps -> Var.t list -> Var.t list
diff --git a/lib/meta_operations/inverse.ml b/lib/meta_operations/inverse.ml
index 057778cf..0a01293a 100644
--- a/lib/meta_operations/inverse.ml
+++ b/lib/meta_operations/inverse.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 open Std
 
 exception NotInvertible of string
diff --git a/lib/meta_operations/inverse.mli b/lib/meta_operations/inverse.mli
index a6158c3a..3ab5c4a9 100644
--- a/lib/meta_operations/inverse.mli
+++ b/lib/meta_operations/inverse.mli
@@ -1,5 +1,4 @@
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val ty : ty -> ty
 val compute_inverse : tm -> tm
diff --git a/lib/meta_operations/opposite.ml b/lib/meta_operations/opposite.ml
index b6fc534d..b2e31c2a 100644
--- a/lib/meta_operations/opposite.ml
+++ b/lib/meta_operations/opposite.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let rec op_data_to_string = function
   | [] -> ""
diff --git a/lib/meta_operations/opposite.mli b/lib/meta_operations/opposite.mli
index 079c2936..816532b6 100644
--- a/lib/meta_operations/opposite.mli
+++ b/lib/meta_operations/opposite.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val op_data_to_string : op_data -> string
 val equiv_op_ps : ps -> op_data -> sub_ps
diff --git a/lib/meta_operations/padding.ml b/lib/meta_operations/padding.ml
index 2e712f9d..635d94e9 100644
--- a/lib/meta_operations/padding.ml
+++ b/lib/meta_operations/padding.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 module type StringS = sig
   val value : string
diff --git a/lib/meta_operations/padding.mli b/lib/meta_operations/padding.mli
index b0ec31e2..bf653101 100644
--- a/lib/meta_operations/padding.mli
+++ b/lib/meta_operations/padding.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 module type StringS = sig
   val value : string
diff --git a/lib/meta_operations/ps_reduction.ml b/lib/meta_operations/ps_reduction.ml
index c1005c0f..db0dd9d0 100644
--- a/lib/meta_operations/ps_reduction.ml
+++ b/lib/meta_operations/ps_reduction.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let tdb i = Var (Var.Db i)
 
diff --git a/lib/meta_operations/ps_reduction.mli b/lib/meta_operations/ps_reduction.mli
index a84c51d5..99de1b40 100644
--- a/lib/meta_operations/ps_reduction.mli
+++ b/lib/meta_operations/ps_reduction.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val reduce : int -> ps -> ps
 val reduction_sub : ps -> sub_ps
diff --git a/lib/meta_operations/suspension.mli b/lib/meta_operations/suspension.mli
index 2d5dc986..1c2c46eb 100644
--- a/lib/meta_operations/suspension.mli
+++ b/lib/meta_operations/suspension.mli
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val ps : int option -> ps -> ps
 val ty : int option -> ty -> ty
diff --git a/lib/meta_operations/telescope.ml b/lib/meta_operations/telescope.ml
index d476e6aa..0feb9885 100644
--- a/lib/meta_operations/telescope.ml
+++ b/lib/meta_operations/telescope.ml
@@ -1,6 +1,5 @@
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 (* returns the associator pairing up the middle two cells of a composite of
     (2*k) 1-cells. The argument is the integer k *)
diff --git a/lib/meta_operations/telescope.mli b/lib/meta_operations/telescope.mli
index 7132b5e7..dd8e4edf 100644
--- a/lib/meta_operations/telescope.mli
+++ b/lib/meta_operations/telescope.mli
@@ -1,5 +1,4 @@
 open Kernel
-open Unchecked_types.Unchecked_types(Coh)(Tm)
 
 val ctx : int -> ctx
 val telescope : int -> tm
diff --git a/rocq_plugin/src/export.ml b/rocq_plugin/src/export.ml
index 88b0c825..67937e04 100644
--- a/rocq_plugin/src/export.ml
+++ b/rocq_plugin/src/export.ml
@@ -4,7 +4,6 @@ open Evd
 open Catt
 open Common
 open Kernel
-open Unchecked_types.Unchecked_types (Coh) (Tm)
 
 let run_catt_on_file f =
   Prover.reset ();

From b99d1343d8614ddf1e8777168c4b990bfec1e7fa Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 10 Oct 2025 01:13:37 +0200
Subject: [PATCH 20/30] [internals] major simplification of internal modules

---
 lib/dune                          |   2 +-
 lib/elaboration/translate_raw.ml  |   1 +
 lib/internals/core.mli            |  31 +
 lib/internals/display_maps.ml     | 135 ++---
 lib/internals/display_maps.mli    |  40 +-
 lib/internals/equality.ml         | 201 +++----
 lib/internals/equality.mli        |  44 +-
 lib/internals/kernel.ml           | 139 ++---
 lib/internals/kernel.mli          |  64 +-
 lib/internals/printing.ml         | 738 +++++++++++------------
 lib/internals/printing.mli        |  46 +-
 lib/internals/signatures.mli      | 106 ----
 lib/internals/syntax.ml           |  54 +-
 lib/internals/syntax.mli          |  56 +-
 lib/internals/unchecked.ml        | 942 +++++++++++++++---------------
 lib/internals/unchecked.mli       | 142 ++++-
 lib/internals/unchecked_types.ml  |  47 --
 lib/internals/unchecked_types.mli |  27 -
 lib/lib/common.ml                 |  18 +
 lib/lib/common.mli                |  17 +
 lib/lib/meta.ml                   |   2 +-
 21 files changed, 1314 insertions(+), 1538 deletions(-)
 create mode 100644 lib/internals/core.mli
 delete mode 100644 lib/internals/signatures.mli
 delete mode 100644 lib/internals/unchecked_types.ml
 delete mode 100644 lib/internals/unchecked_types.mli

diff --git a/lib/dune b/lib/dune
index 4a064f5f..b65089de 100644
--- a/lib/dune
+++ b/lib/dune
@@ -3,7 +3,7 @@
 (library
  (name catt)
  (public_name catt)
- (modules_without_implementation raw_types signatures)
+ (modules_without_implementation raw_types core)
  (libraries base)
  (instrumentation
   (backend landmarks --auto)))
diff --git a/lib/elaboration/translate_raw.ml b/lib/elaboration/translate_raw.ml
index 43482831..7e5420c8 100644
--- a/lib/elaboration/translate_raw.ml
+++ b/lib/elaboration/translate_raw.ml
@@ -1,5 +1,6 @@
 open Kernel
 open Raw_types
+open Common
 
 exception WrongNumberOfArguments
 
diff --git a/lib/internals/core.mli b/lib/internals/core.mli
new file mode 100644
index 00000000..ae5948ec
--- /dev/null
+++ b/lib/internals/core.mli
@@ -0,0 +1,31 @@
+open Common
+
+module type S = sig
+  module rec Coh : sig
+    type t
+
+    val forget : t -> ps * (t, Tm.t) ty * pp_data
+    val check : ps -> (t, Tm.t) ty -> pp_data -> t
+    val to_string : ?unroll:bool -> t -> string
+    val func_data : t -> (Var.t * int) list list
+    val is_equal : t -> t -> bool
+  end
+
+  and Tm : sig
+    type t
+
+    val develop : t -> (Coh.t, t) tm
+    val func_data : t -> (Var.t * int) list list option
+    val name : t -> string option
+    val full_name : t -> string option
+    val ctx : t -> (Coh.t, t) ctx
+    val is_equal : t -> t -> bool
+
+    val apply :
+      ((Coh.t, Tm.t) ctx -> (Coh.t, t) ctx) ->
+      ((Coh.t, t) tm -> (Coh.t, t) tm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, t) sub
+  end
+end
diff --git a/lib/internals/display_maps.ml b/lib/internals/display_maps.ml
index 14b9947b..f2eb7fcb 100644
--- a/lib/internals/display_maps.ml
+++ b/lib/internals/display_maps.ml
@@ -1,88 +1,63 @@
 open Std
 open Common
-open Unchecked_types
 
-module DisplayMaps (CohT : sig
-  type t
-end) (TmT : sig
-  type t
-end) =
-struct
-  open Unchecked_types (CohT) (TmT)
+module Make (Core : Core.S) = struct
+  module Unchecked = Unchecked.Make (Core)
 
-  module Make (Coh : sig
-    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
-    val check : ps -> ty -> pp_data -> CohT.t
-  end) (Tm : sig
-    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
+  let var_apply_sub v s =
+    match Unchecked.tm_apply_sub (Var v) s with
+    | Var v -> v
+    | _ -> Error.fatal "image of a variable by a display map must be a variable"
 
-    val apply :
-      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
-      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
-      (pp_data -> pp_data) ->
-      TmT.t ->
-      TmT.t * Unchecked_types(CohT)(TmT).sub
-  end) =
-  struct
-    module U = Unchecked.Unchecked (CohT) (TmT)
-    module Unchecked = U.Make (Coh) (Tm)
+  (* Pullback of a substitution along a display map. Returns the resulting
+   * context with the right canonical inclusion. The left canonical inclusion is
+   *  the identity. *)
+  let rec pullback c1 sub c2 dm =
+    match (c2, dm) with
+    | [], [] -> (c1, [])
+    | (x, (_, expl)) :: ctx, (p, (Var y, _)) :: dm when x = y ->
+        let ctx, names = pullback c1 sub ctx dm in
+        (ctx, (x, (Unchecked.tm_apply_sub (Var p) sub, expl)) :: names)
+    | (x, (ty, expl)) :: ctx, (_ as dm) ->
+        let ctx, names = pullback c1 sub ctx dm in
+        let newvar = Var.fresh () in
+        let ty = Unchecked.ty_apply_sub ty names in
+        ((newvar, (ty, expl)) :: ctx, (x, (Var newvar, expl)) :: names)
+    | [], _ :: _ ->
+        Error.fatal
+          "wrong data for pullback: display map cannot be longer than the \
+           context"
 
-    let var_apply_sub v s =
-      match Unchecked.tm_apply_sub (Var v) s with
-      | Var v -> v
-      | _ ->
-          Error.fatal "image of a variable by a display map must be a variable"
+  (* Universal property of the pullback, gluing substitutions s1 and s2. Requires
+   * the inr canonical inclusion, the second context and the display map *)
+  let rec glue s1 s2 inr c2 dm =
+    match (s2, c2, dm) with
+    | [], [], [] -> s1
+    | (z, _) :: s2, (x, _) :: c2, (_, (Var y, _)) :: dm when x = y && x = z ->
+        let s = glue s1 s2 inr c2 dm in
+        s
+    | (z, (t, e)) :: s2, (x, _) :: c2, (_ as dm) when x = z ->
+        let s = glue s1 s2 inr c2 dm in
+        let var =
+          match Unchecked.tm_apply_sub (Var x) inr with
+          | Var x -> x
+          | _ -> assert false
+        in
+        (var, (t, e)) :: s
+    | _, [], _ :: _ ->
+        Error.fatal
+          "wrong data for pullback gluing: display map cannot be longer than \
+           the context"
+    | _, _, _ ->
+        Error.fatal
+          "wrong data pullback gluing: substitution must point to the context"
 
-    (* Pullback of a substitution along a display map. Returns the resulting
-     * context with the right canonical inclusion. The left canonical inclusion is
-     *  the identity. *)
-    let rec pullback c1 sub c2 dm =
-      match (c2, dm) with
-      | [], [] -> (c1, [])
-      | (x, (_, expl)) :: ctx, (p, (Var y, _)) :: dm when x = y ->
-          let ctx, names = pullback c1 sub ctx dm in
-          (ctx, (x, (Unchecked.tm_apply_sub (Var p) sub, expl)) :: names)
-      | (x, (ty, expl)) :: ctx, (_ as dm) ->
-          let ctx, names = pullback c1 sub ctx dm in
-          let newvar = Var.fresh () in
-          let ty = Unchecked.ty_apply_sub ty names in
-          ((newvar, (ty, expl)) :: ctx, (x, (Var newvar, expl)) :: names)
-      | [], _ :: _ ->
-          Error.fatal
-            "wrong data for pullback: display map cannot be longer than the \
-             context"
-
-    (* Universal property of the pullback, gluing substitutions s1 and s2. Requires
-     * the inr canonical inclusion, the second context and the display map *)
-    let rec glue s1 s2 inr c2 dm =
-      match (s2, c2, dm) with
-      | [], [], [] -> s1
-      | (z, _) :: s2, (x, _) :: c2, (_, (Var y, _)) :: dm when x = y && x = z ->
-          let s = glue s1 s2 inr c2 dm in
-          s
-      | (z, (t, e)) :: s2, (x, _) :: c2, (_ as dm) when x = z ->
-          let s = glue s1 s2 inr c2 dm in
-          let var =
-            match Unchecked.tm_apply_sub (Var x) inr with
-            | Var x -> x
-            | _ -> assert false
-          in
-          (var, (t, e)) :: s
-      | _, [], _ :: _ ->
-          Error.fatal
-            "wrong data for pullback gluing: display map cannot be longer than \
-             the context"
-      | _, _, _ ->
-          Error.fatal
-            "wrong data pullback gluing: substitution must point to the context"
-
-    let pp_data_rename pp names =
-      let name, susp, func = pp in
-      let rec rename f =
-        match f with
-        | [] -> []
-        | (x, i) :: f -> (var_apply_sub x names, i) :: rename f
-      in
-      (name, susp, List.map rename func)
-  end
+  let pp_data_rename pp names =
+    let name, susp, func = pp in
+    let rec rename f =
+      match f with
+      | [] -> []
+      | (x, i) :: f -> (var_apply_sub x names, i) :: rename f
+    in
+    (name, susp, List.map rename func)
 end
diff --git a/lib/internals/display_maps.mli b/lib/internals/display_maps.mli
index 12fb0436..bb5a801c 100644
--- a/lib/internals/display_maps.mli
+++ b/lib/internals/display_maps.mli
@@ -1,25 +1,23 @@
-open Common
-open Unchecked_types
+module Make (Core : Core.S) : sig
+  open Core
+  open Common
 
-module DisplayMaps (Coh : sig
-  type t
-end) (Tm : sig
-  type t
-end) : sig
-  open Unchecked_types(Coh)(Tm)
-  open Signatures.Signatures(Coh)(Tm)
+  val var_apply_sub : Var.t -> (Coh.t, Tm.t) sub -> Var.t
 
-  module Make (_ : sig
-    val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
-    val check : ps -> ty -> pp_data -> Coh.t
-  end) (_ : sig
-    val develop : Tm.t -> Unchecked_types(Coh)(Tm).tm
+  val pullback :
+    (Coh.t, Tm.t) ctx ->
+    (Coh.t, Tm.t) sub ->
+    (Coh.t, Tm.t) ctx ->
+    (Coh.t, Tm.t) sub ->
+    (Coh.t, Tm.t) ctx * (Coh.t, Tm.t) sub
 
-    val apply :
-      (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-      (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
-      (pp_data -> pp_data) ->
-      Tm.t ->
-      Tm.t * Unchecked_types(Coh)(Tm).sub
-  end) : DisplayMapsS
+  val glue :
+    (Coh.t, Tm.t) sub ->
+    (Coh.t, Tm.t) sub ->
+    (Coh.t, Tm.t) sub ->
+    (Coh.t, Tm.t) ctx ->
+    (Coh.t, Tm.t) sub ->
+    (Coh.t, Tm.t) sub
+
+  val pp_data_rename : pp_data -> (Coh.t, Tm.t) sub -> pp_data
 end
diff --git a/lib/internals/equality.ml b/lib/internals/equality.ml
index 69fd097b..fdb12d53 100644
--- a/lib/internals/equality.ml
+++ b/lib/internals/equality.ml
@@ -1,133 +1,100 @@
 open Std
 open Common
-open Unchecked_types
 
-module Equality (CohT : sig
-  type t
-end) (TmT : sig
-  type t
-end) =
-struct
-  open Unchecked_types (CohT) (TmT)
+module Make (Core : Core.S) = struct
+  open Core
+  module Unchecked = Unchecked.Make (Core)
+  module Printing = Printing.Make (Core)
 
-  module Make (Coh : sig
-    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
-    val to_string : ?unroll:bool -> CohT.t -> string
-    val func_data : CohT.t -> (Var.t * int) list list
-    val is_equal : CohT.t -> CohT.t -> bool
-    val check : ps -> ty -> pp_data -> CohT.t
-  end) (Tm : sig
-    val func_data : TmT.t -> (Var.t * int) list list option
-    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
-    val name : TmT.t -> string option
-    val full_name : TmT.t -> string option
-    val ctx : TmT.t -> ctx
-    val is_equal : TmT.t -> TmT.t -> bool
+  let rec is_equal_ps ps1 ps2 =
+    match (ps1, ps2) with
+    | Br [], Br [] -> true
+    | Br (ps1 :: l1), Br (ps2 :: l2) -> (
+        is_equal_ps ps1 ps2
+        && try List.for_all2 is_equal_ps l1 l2 with Invalid_argument _ -> true)
+    | Br [], Br (_ :: _) | Br (_ :: _), Br [] -> false
 
-    val apply :
-      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
-      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
-      (pp_data -> pp_data) ->
-      TmT.t ->
-      TmT.t * Unchecked_types(CohT)(TmT).sub
-  end) =
-  struct
-    module U = Unchecked.Unchecked (CohT) (TmT)
-    module Unchecked = U.Make (Coh) (Tm)
-    module P = Printing.Printing (CohT) (TmT) (Unchecked)
-    module Printing = P.Make (Coh) (Tm)
+  let rec is_equal_ty ty1 ty2 =
+    match (ty1, ty2) with
+    | Meta_ty i, Meta_ty j -> i = j
+    | Obj, Obj -> true
+    | Arr (ty1, u1, v1), Arr (ty2, u2, v2) ->
+        is_equal_ty ty1 ty2 && is_equal_tm u1 u2 && is_equal_tm v1 v2
+    | Obj, Arr _
+    | Arr _, Obj
+    | Meta_ty _, Obj
+    | Meta_ty _, Arr _
+    | Obj, Meta_ty _
+    | Arr _, Meta_ty _ ->
+        false
 
-    let rec is_equal_ps ps1 ps2 =
-      match (ps1, ps2) with
-      | Br [], Br [] -> true
-      | Br (ps1 :: l1), Br (ps2 :: l2) -> (
-          is_equal_ps ps1 ps2
-          &&
-          try List.for_all2 is_equal_ps l1 l2 with Invalid_argument _ -> true)
-      | Br [], Br (_ :: _) | Br (_ :: _), Br [] -> false
+  and is_equal_tm tm1 tm2 =
+    match (tm1, tm2) with
+    | Var v1, Var v2 -> Var.is_equal v1 v2
+    | Meta_tm i, Meta_tm j -> i = j
+    | Coh (coh1, s1), Coh (coh2, s2) ->
+        Coh.is_equal coh1 coh2 && is_equal_sub_ps s1 s2
+    | App (t1, s1), App (t2, s2) when t1 == t2 ->
+        is_equal_sub_on_support t1 s1 s2
+    | App (t, s), ((Coh _ | App _ | Var _) as tm2)
+    | ((Coh _ | Var _) as tm2), App (t, s) ->
+        let c = Tm.develop t in
+        is_equal_tm (Unchecked.tm_apply_sub c s) tm2
+    | Var _, Coh _
+    | Coh _, Var _
+    | Meta_tm _, Var _
+    | Meta_tm _, Coh _
+    | Var _, Meta_tm _
+    | Coh _, Meta_tm _
+    | App _, Meta_tm _
+    | Meta_tm _, App _ ->
+        false
 
-    let rec is_equal_ty ty1 ty2 =
-      match (ty1, ty2) with
-      | Meta_ty i, Meta_ty j -> i = j
-      | Obj, Obj -> true
-      | Arr (ty1, u1, v1), Arr (ty2, u2, v2) ->
-          is_equal_ty ty1 ty2 && is_equal_tm u1 u2 && is_equal_tm v1 v2
-      | Obj, Arr _
-      | Arr _, Obj
-      | Meta_ty _, Obj
-      | Meta_ty _, Arr _
-      | Obj, Meta_ty _
-      | Arr _, Meta_ty _ ->
-          false
+  and is_equal_sub_ps s1 s2 =
+    List.for_all2 (fun (t1, _) (t2, _) -> is_equal_tm t1 t2) s1 s2
 
-    and is_equal_tm tm1 tm2 =
-      match (tm1, tm2) with
-      | Var v1, Var v2 -> Var.is_equal v1 v2
-      | Meta_tm i, Meta_tm j -> i = j
-      | Coh (coh1, s1), Coh (coh2, s2) ->
-          Coh.is_equal coh1 coh2 && is_equal_sub_ps s1 s2
-      | App (t1, s1), App (t2, s2) when t1 == t2 ->
-          is_equal_sub_on_support t1 s1 s2
-      | App (t, s), ((Coh _ | App _ | Var _) as tm2)
-      | ((Coh _ | Var _) as tm2), App (t, s) ->
-          let c = Tm.develop t in
-          is_equal_tm (Unchecked.tm_apply_sub c s) tm2
-      | Var _, Coh _
-      | Coh _, Var _
-      | Meta_tm _, Var _
-      | Meta_tm _, Coh _
-      | Var _, Meta_tm _
-      | Coh _, Meta_tm _
-      | App _, Meta_tm _
-      | Meta_tm _, App _ ->
-          false
+  and is_equal_sub_on_support t s1 s2 =
+    List.for_all2
+      (fun (x, (t1, _)) (y, (t2, _)) ->
+        Var.is_equal x y
+        && ((not (Unchecked.tm_contains_var (Tm.develop t) x))
+           || is_equal_tm t1 t2))
+      s1 s2
 
-    and is_equal_sub_ps s1 s2 =
-      List.for_all2 (fun (t1, _) (t2, _) -> is_equal_tm t1 t2) s1 s2
+  let rec is_equal_ctx ctx1 ctx2 =
+    match (ctx1, ctx2) with
+    | [], [] -> true
+    | (v1, (t1, _)) :: c1, (v2, (t2, _)) :: c2 ->
+        Var.is_equal v1 v2 && is_equal_ty t1 t2 && is_equal_ctx c1 c2
+    | _ :: _, [] | [], _ :: _ -> false
 
-    and is_equal_sub_on_support t s1 s2 =
-      List.for_all2
-        (fun (x, (t1, _)) (y, (t2, _)) ->
-          Var.is_equal x y
-          && ((not (Unchecked.tm_contains_var (Tm.develop t) x))
-             || is_equal_tm t1 t2))
-        s1 s2
+  let is_equal_ps ps1 ps2 = ps1 == ps2 || is_equal_ps ps1 ps2
+  let is_equal_ty ty1 ty2 = ty1 == ty2 || is_equal_ty ty1 ty2
+  let is_equal_tm tm1 tm2 = tm1 == tm2 || is_equal_tm tm1 tm2
+  let is_equal_sub_ps s1 s2 = s1 == s2 || is_equal_sub_ps s1 s2
+  let is_equal_ctx ctx1 ctx2 = ctx1 == ctx2 || is_equal_ctx ctx1 ctx2
 
-    let rec is_equal_ctx ctx1 ctx2 =
-      match (ctx1, ctx2) with
-      | [], [] -> true
-      | (v1, (t1, _)) :: c1, (v2, (t2, _)) :: c2 ->
-          Var.is_equal v1 v2 && is_equal_ty t1 t2 && is_equal_ctx c1 c2
-      | _ :: _, [] | [], _ :: _ -> false
+  let check_equal_ty ty1 ty2 =
+    if not (is_equal_ty ty1 ty2) then
+      raise (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
 
-    let is_equal_ps ps1 ps2 = ps1 == ps2 || is_equal_ps ps1 ps2
-    let is_equal_ty ty1 ty2 = ty1 == ty2 || is_equal_ty ty1 ty2
-    let is_equal_tm tm1 tm2 = tm1 == tm2 || is_equal_tm tm1 tm2
-    let is_equal_sub_ps s1 s2 = s1 == s2 || is_equal_sub_ps s1 s2
-    let is_equal_ctx ctx1 ctx2 = ctx1 == ctx2 || is_equal_ctx ctx1 ctx2
+  let check_equal_tm tm1 tm2 =
+    if not (is_equal_tm tm1 tm2) then
+      raise (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
 
-    let check_equal_ty ty1 ty2 =
-      if not (is_equal_ty ty1 ty2) then
-        raise (NotEqual (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
+  let check_equal_sub_ps s1 s2 =
+    if not (is_equal_sub_ps s1 s2) then ()
+    else
+      raise
+        (NotEqual (Printing.sub_ps_to_string s1, Printing.sub_ps_to_string s2))
 
-    let check_equal_tm tm1 tm2 =
-      if not (is_equal_tm tm1 tm2) then
-        raise (NotEqual (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
+  let check_equal_ctx ctx1 ctx2 =
+    if ctx1 == ctx2 || is_equal_ctx ctx1 ctx2 then ()
+    else
+      raise
+        (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
 
-    let check_equal_sub_ps s1 s2 =
-      if not (is_equal_sub_ps s1 s2) then ()
-      else
-        raise
-          (NotEqual (Printing.sub_ps_to_string s1, Printing.sub_ps_to_string s2))
-
-    let check_equal_ctx ctx1 ctx2 =
-      if ctx1 == ctx2 || is_equal_ctx ctx1 ctx2 then ()
-      else
-        raise
-          (NotEqual (Printing.ctx_to_string ctx1, Printing.ctx_to_string ctx2))
-
-    let check_equal_ps ps1 ps2 =
-      if not (is_equal_ps ps1 ps2) then
-        raise (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
-  end
+  let check_equal_ps ps1 ps2 =
+    if not (is_equal_ps ps1 ps2) then
+      raise (NotEqual (Printing.ps_to_string ps1, Printing.ps_to_string ps2))
 end
diff --git a/lib/internals/equality.mli b/lib/internals/equality.mli
index 3803acf5..501bdab7 100644
--- a/lib/internals/equality.mli
+++ b/lib/internals/equality.mli
@@ -1,34 +1,14 @@
-open Common
-open Unchecked_types
-open Signatures
+module Make (Core : Core.S) : sig
+  open Core
+  open Common
 
-module Equality (Coh : sig
-  type t
-end) (Tm : sig
-  type t
-end) : sig
-  open Unchecked_types(Coh)(Tm)
-  open Signatures(Coh)(Tm)
-
-  module Make (_ : sig
-    val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
-    val to_string : ?unroll:bool -> Coh.t -> string
-    val func_data : Coh.t -> (Var.t * int) list list
-    val is_equal : Coh.t -> Coh.t -> bool
-    val check : ps -> ty -> pp_data -> Coh.t
-  end) (_ : sig
-    val func_data : Tm.t -> (Var.t * int) list list option
-    val develop : Tm.t -> Unchecked_types(Coh)(Tm).tm
-    val name : Tm.t -> string option
-    val full_name : Tm.t -> string option
-    val ctx : Tm.t -> ctx
-    val is_equal : Tm.t -> Tm.t -> bool
-
-    val apply :
-      (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-      (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
-      (pp_data -> pp_data) ->
-      Tm.t ->
-      Tm.t * Unchecked_types(Coh)(Tm).sub
-  end) : EqualityS
+  val check_equal_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx -> unit
+  val check_equal_ps : ps -> ps -> unit
+  val check_equal_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty -> unit
+  val check_equal_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> unit
+  val check_equal_sub_ps : (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps -> unit
+  val is_equal_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx -> bool
+  val is_equal_ps : ps -> ps -> bool
+  val is_equal_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty -> bool
+  val is_equal_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> bool
 end
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index d36d7cae..a43bb086 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -1,6 +1,5 @@
 open Std
 open Common
-open Unchecked_types
 
 exception IsObj
 exception IsCoh
@@ -11,9 +10,9 @@ exception MetaVariable
 module rec Sub : sig
   type t
 
-  val check : Ctx.t -> Unchecked_types(Coh)(Tm).sub -> Ctx.t -> t
-  val check_to_ps : Ctx.t -> Unchecked_types(Coh)(Tm).sub_ps -> PS.t -> t
-  val forget : t -> Unchecked_types(Coh)(Tm).sub
+  val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
+  val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> t
+  val forget : t -> (Coh.t, Tm.t) sub
   val free_vars : t -> Var.t list
   val src : t -> Ctx.t
   val tgt : t -> Ctx.t
@@ -22,14 +21,18 @@ end = struct
     list : Tm.t list;
     src : Ctx.t;
     tgt : Ctx.t;
-    unchecked : Unchecked_types(Coh)(Tm).sub;
+    unchecked : (Coh.t, Tm.t) sub;
   }
 
   let src s = s.src
   let tgt s = s.tgt
 
-  module Syntax = Syntax.Syntax (Coh) (Tm)
-  open Syntax.Make (Coh) (Tm)
+  module Core = struct
+    module Coh = Coh
+    module Tm = Tm
+  end
+
+  open Syntax.Make (Core)
 
   let tbl : (Ctx.t * PS.t * sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
   let free_vars s = List.concat (List.map Tm.free_vars s.list)
@@ -87,17 +90,21 @@ and Ctx : sig
   val ty_var : t -> Var.t -> Ty.t
   val domain : t -> Var.t list
   val value : t -> (Var.t * Ty.t) list
-  val extend : t -> expl:bool -> Var.t -> Unchecked_types(Coh)(Tm).ty -> t
-  val forget : t -> Unchecked_types(Coh)(Tm).ctx
-  val check : Unchecked_types(Coh)(Tm).ctx -> t
+  val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
+  val forget : t -> (Coh.t, Tm.t) ctx
+  val check : (Coh.t, Tm.t) ctx -> t
   val check_notin : t -> Var.t -> unit
   val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
 end = struct
-  type t = { c : (Var.t * Ty.t) list; unchecked : Unchecked_types(Coh)(Tm).ctx }
+  type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
+
+  module Core = struct
+    module Coh = Coh
+    module Tm = Tm
+  end
 
-  module Syntax = Syntax.Syntax (Coh) (Tm)
-  open Syntax.Make (Coh) (Tm)
+  open Syntax.Make (Core)
 
   let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
@@ -171,8 +178,12 @@ and PS : sig
 end = struct
   exception Invalid
 
-  module Syntax = Syntax.Syntax (Coh) (Tm)
-  open Syntax.Make (Coh) (Tm)
+  module Core = struct
+    module Coh = Coh
+    module Tm = Tm
+  end
+
+  open Syntax.Make (Core)
 
   (** A pasting scheme. *)
   type ps_derivation =
@@ -316,8 +327,8 @@ and Ty : sig
   val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
   val morphism : Tm.t -> Tm.t -> Ty.t
-  val forget : t -> Unchecked_types(Coh)(Tm).ty
-  val check : Ctx.t -> Unchecked_types(Coh)(Tm).ty -> t
+  val forget : t -> (Coh.t, Tm.t) ty
+  val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
   val apply_sub : t -> Sub.t -> t
   val retrieve_arrow : t -> t * Tm.t * Tm.t
   val under_type : t -> t
@@ -326,8 +337,12 @@ and Ty : sig
   val ctx : t -> Ctx.t
   val dim : t -> int
 end = struct
-  module Syntax = Syntax.Syntax (Coh) (Tm)
-  open Syntax.Make (Coh) (Tm)
+  module Core = struct
+    module Coh = Coh
+    module Tm = Tm
+  end
+
+  open Syntax.Make (Core)
 
   (** A type exepression. *)
   type expr = Obj | Arr of t * Tm.t * Tm.t
@@ -412,11 +427,11 @@ and Tm : sig
   (* Data extraction *)
   val to_var : t -> Var.t
   val typ : t -> Ty.t
-  val ty : t -> Unchecked_types(Coh)(Tm).ty
+  val ty : t -> (Coh.t, Tm.t) ty
   val bdry : t -> t * t
-  val ctx : t -> Unchecked_types(Coh)(Tm).ctx
-  val forget : t -> Unchecked_types(Coh)(Tm).tm
-  val constr : t -> Unchecked_types(Coh)(Tm).constr
+  val ctx : t -> (Coh.t, Tm.t) ctx
+  val forget : t -> (Coh.t, Tm.t) tm
+  val constr : t -> (Coh.t, Tm.t) constr
   val name : t -> string option
   val full_name : t -> string option
   val func_data : t -> (Var.t * int) list list option
@@ -429,25 +444,26 @@ and Tm : sig
 
   (* Production of terms *)
   val of_coh : Coh.t -> t
-
-  val check :
-    Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> Unchecked_types(Coh)(Tm).tm -> t
-
+  val check : Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
   val apply_sub : t -> Sub.t -> t
   val preimage : t -> Sub.t -> t
-  val develop : t -> Unchecked_types(Coh)(Tm).tm
+  val develop : t -> (Coh.t, Tm.t) tm
 
   val apply :
-    (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-    (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
+    ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+    ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
     (pp_data -> pp_data) ->
     t ->
-    t * Unchecked_types(Coh)(Tm).sub
+    t * (Coh.t, Tm.t) sub
 
   val is_equal : t -> t -> bool
 end = struct
-  module Syntax = Syntax.Syntax (Coh) (Tm)
-  open Syntax.Make (Coh) (Tm)
+  module Core = struct
+    module Coh = Coh
+    module Tm = Tm
+  end
+
+  open Syntax.Make (Core)
 
   type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
 
@@ -588,34 +604,15 @@ and Coh : sig
 
   val ps : t -> PS.t
   val ty : t -> Ty.t
-  val src : t -> Unchecked_types(Coh)(Tm).tm
-  val tgt : t -> Unchecked_types(Coh)(Tm).tm
-  val check : ps -> Unchecked_types(Coh)(Tm).ty -> pp_data -> t
-
-  val check_noninv :
-    ps ->
-    Unchecked_types(Coh)(Tm).tm ->
-    Unchecked_types(Coh)(Tm).tm ->
-    pp_data ->
-    t
-
-  val check_inv :
-    ps ->
-    Unchecked_types(Coh)(Tm).tm ->
-    Unchecked_types(Coh)(Tm).tm ->
-    pp_data ->
-    t
-
+  val src : t -> (t, Tm.t) tm
+  val tgt : t -> (t, Tm.t) tm
+  val check : ps -> (t, Tm.t) ty -> pp_data -> t
+  val check_noninv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
+  val check_inv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
   val to_string : ?unroll:bool -> t -> string
   val is_inv : t -> bool
-
-  val noninv_srctgt :
-    t ->
-    Unchecked_types(Coh)(Tm).tm
-    * Unchecked_types(Coh)(Tm).tm
-    * Unchecked_types(Coh)(Tm).ty
-
-  val forget : t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
+  val noninv_srctgt : t -> (t, Tm.t) tm * (t, Tm.t) tm * (t, Tm.t) ty
+  val forget : t -> ps * (t, Tm.t) ty * pp_data
   val func_data : t -> (Var.t * int) list list
   val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
@@ -623,24 +620,28 @@ and Coh : sig
 
   val apply_ps :
     (ps -> ps) ->
-    (Unchecked_types(Coh)(Tm).ty -> Unchecked_types(Coh)(Tm).ty) ->
+    ((t, Tm.t) ty -> (t, Tm.t) ty) ->
     (pp_data -> pp_data) ->
     t ->
     t
 
   val apply :
-    (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-    (Unchecked_types(Coh)(Tm).ty -> Unchecked_types(Coh)(Tm).ty) ->
+    ((t, Tm.t) ctx -> (t, Tm.t) ctx) ->
+    ((t, Tm.t) ty -> (t, Tm.t) ty) ->
     (pp_data -> pp_data) ->
     t ->
-    t * Unchecked_types(Coh)(Tm).sub
+    t * (t, Tm.t) sub
 end = struct
   type cohInv = { ps : PS.t; ty : Ty.t }
   type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
   type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
 
-  module Syntax = Syntax.Syntax (Coh) (Tm)
-  open Syntax.Make (Coh) (Tm)
+  module Core = struct
+    module Coh = Coh
+    module Tm = Tm
+  end
+
+  open Syntax.Make (Core)
 
   let tbl : (ps * ty, Coh.t) Hashtbl.t = Hashtbl.create 7829
   let tbl_inv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
@@ -801,8 +802,12 @@ end = struct
     (check ps ty pp_data, db_sub)
 end
 
-module Syntax = Syntax.Syntax (Coh) (Tm)
-include Syntax.Make (Coh) (Tm)
+module Core = struct
+  module Coh = Coh
+  module Tm = Tm
+end
+
+include Syntax.Make (Core)
 
 let check check_fn name =
   let v = 2 in
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index aa1c4aa7..0625bb32 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,90 +1,78 @@
 open Common
-open Unchecked_types
 
 module rec Coh : sig
   type t
 
-  val forget : t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
+  val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
   val is_equal : t -> t -> bool
   val check_equal : t -> t -> unit
   val is_inv : t -> bool
   val to_string : ?unroll:bool -> t -> string
   val dim : t -> int
-  val src : t -> Unchecked_types(Coh)(Tm).tm
-  val tgt : t -> Unchecked_types(Coh)(Tm).tm
-  val check : ps -> Unchecked_types(Coh)(Tm).ty -> pp_data -> t
-
-  val check_noninv :
-    ps ->
-    Unchecked_types(Coh)(Tm).tm ->
-    Unchecked_types(Coh)(Tm).tm ->
-    pp_data ->
-    t
-
-  val check_inv :
-    ps ->
-    Unchecked_types(Coh)(Tm).tm ->
-    Unchecked_types(Coh)(Tm).tm ->
-    pp_data ->
-    t
+  val src : t -> (Coh.t, Tm.t) tm
+  val tgt : t -> (Coh.t, Tm.t) tm
+  val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
+  val check_noninv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
+  val check_inv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
 
   val noninv_srctgt :
-    t ->
-    Unchecked_types(Coh)(Tm).tm
-    * Unchecked_types(Coh)(Tm).tm
-    * Unchecked_types(Coh)(Tm).ty
+    t -> (Coh.t, Tm.t) tm * (Coh.t, Tm.t) tm * (Coh.t, Tm.t) ty
 
   val func_data : t -> (Var.t * int) list list
 
   val apply_ps :
     (ps -> ps) ->
-    (Unchecked_types(Coh)(Tm).ty -> Unchecked_types(Coh)(Tm).ty) ->
+    ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
     (pp_data -> pp_data) ->
     t ->
     t
 
   val apply :
-    (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-    (Unchecked_types(Coh)(Tm).ty -> Unchecked_types(Coh)(Tm).ty) ->
+    ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+    ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
     (pp_data -> pp_data) ->
     t ->
-    t * Unchecked_types(Coh)(Tm).sub
+    t * (Coh.t, Tm.t) sub
 end
 
 and Ty : sig
   type t
 
-  val forget : t -> Unchecked_types(Coh)(Tm).ty
+  val forget : t -> (Coh.t, Tm.t) ty
 end
 
 and Tm : sig
   type t
 
   val typ : t -> Ty.t
-  val ty : t -> Unchecked_types(Coh)(Tm).ty
-  val forget : t -> Unchecked_types(Coh)(Tm).tm
-  val constr : t -> Unchecked_types(Coh)(Tm).constr
+  val ty : t -> (Coh.t, Tm.t) ty
+  val forget : t -> (Coh.t, Tm.t) tm
+  val constr : t -> (Coh.t, Tm.t) constr
   val bdry : t -> t * t
-  val ctx : t -> Unchecked_types(Coh)(Tm).ctx
+  val ctx : t -> (Coh.t, Tm.t) ctx
   val name : t -> string option
   val full_name : t -> string option
   val func_data : t -> (Var.t * int) list list option
   val of_coh : Coh.t -> t
-  val develop : t -> Unchecked_types(Coh)(Tm).tm
+  val develop : t -> (Coh.t, Tm.t) tm
   val pp_data : t -> pp_data option
   val to_string : t -> string
   val is_equal : t -> t -> bool
 
   val apply :
-    (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-    (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
+    ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+    ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
     (pp_data -> pp_data) ->
     t ->
-    t * Unchecked_types(Coh)(Tm).sub
+    t * (Coh.t, Tm.t) sub
+end
+
+module Core : sig
+  module Coh = Coh
+  module Tm = Tm
 end
 
-open Syntax.Syntax(Coh)(Tm)
-include module type of Make (Coh) (Tm)
+include module type of Syntax.Make (Core)
 
 module Ctx : sig
   type t
diff --git a/lib/internals/printing.ml b/lib/internals/printing.ml
index 6af4351c..b1bb7038 100644
--- a/lib/internals/printing.ml
+++ b/lib/internals/printing.ml
@@ -1,401 +1,371 @@
 open Common
-open Unchecked_types
-
-module Printing (CohT : sig
-  type t
-end) (TmT : sig
-  type t
-end) (App : sig
-  val tm_apply_sub :
-    Unchecked_types(CohT)(TmT).tm ->
-    Unchecked_types(CohT)(TmT).sub ->
-    Unchecked_types(CohT)(TmT).tm
-end) =
-struct
-  open Unchecked_types (CohT) (TmT)
-
-  module Make (Coh : sig
-    val to_string : ?unroll:bool -> CohT.t -> string
-    val func_data : CohT.t -> (Var.t * int) list list
-    val forget : CohT.t -> ps * ty * pp_data
-    val is_equal : CohT.t -> CohT.t -> bool
-  end) (Tm : sig
-    val func_data : TmT.t -> (Var.t * int) list list option
-    val name : TmT.t -> string option
-    val full_name : TmT.t -> string option
-    val develop : TmT.t -> tm
-    val ctx : TmT.t -> ctx
-    val is_equal : TmT.t -> TmT.t -> bool
-  end) =
-  struct
-    module Regular = struct
-      let rec func_to_string func =
-        let rec print_list = function
-          | [] -> ""
-          | [ (x, n) ] -> Printf.sprintf "(%s,%d)" (Var.to_string x) n
-          | (x, n) :: l ->
-              Printf.sprintf "%s (%s,%d)" (print_list l) (Var.to_string x) n
-        in
-        match func with
-        | [] -> ""
-        | l :: func ->
-            Printf.sprintf "%s[%s]" (func_to_string func) (print_list l)
-
-      let rec bracket i s =
-        if i <= 0 then s else Printf.sprintf "[%s]" (bracket (i - 1) s)
-
-      let rec ps_to_string = function
-        | Br l ->
-            Printf.sprintf "[%s]"
-              (List.fold_left
-                 (fun s ps -> Printf.sprintf "%s%s" (ps_to_string ps) s)
-                 "" l)
-
-      let rec ty_to_string = function
-        | Meta_ty i -> Printf.sprintf "_ty%i" i
-        | Obj -> "*"
-        | Arr (a, u, v) ->
-            if !Settings.verbosity >= 3 then
-              Printf.sprintf "%s | %s -> %s" (ty_to_string a) (tm_to_string u)
-                (tm_to_string v)
-            else Printf.sprintf "%s -> %s" (tm_to_string u) (tm_to_string v)
-
-      and tm_to_string = function
-        | Var v -> Var.to_string v
-        | Meta_tm i -> Printf.sprintf "_tm%i" i
-        | Coh (c, s) ->
-            if !Settings.unroll_coherences then
-              Printf.sprintf "%s[%s]" (Coh.to_string c) (sub_ps_to_string s)
-            else
-              let func = Coh.func_data c in
-              Printf.sprintf "(%s%s)" (Coh.to_string c)
-                (sub_ps_to_string ~func s)
-        | App (t, s) -> (
-            match Tm.name t with
-            | Some name ->
-                let func = Tm.func_data t in
-                let str_s, expl = sub_to_string ?func s in
-                let expl_str = if expl then "@" else "" in
-                Printf.sprintf "(%s%s%s)" expl_str name str_s
-            | None -> tm_to_string (App.tm_apply_sub (Tm.develop t) s))
-
-      and sub_ps_to_string ?(func = []) s =
-        match func with
-        | [] -> sub_ps_to_string_nofunc s
-        | func :: _ -> sub_ps_to_string_func s func
-
-      and sub_ps_to_string_nofunc s =
-        match s with
-        | [] -> ""
-        | (t, expl) :: s ->
-            if expl || !Settings.print_explicit_substitutions then
-              Printf.sprintf "%s %s" (sub_ps_to_string s) (tm_to_string t)
-            else sub_ps_to_string s
-
-      and sub_ps_to_string_func s func =
-        let rec print s =
-          match s with
-          | (t, true) :: s ->
-              let str, x = print s in
-              let arg =
-                match List.assoc_opt (Var.Db x) func with
-                | None -> tm_to_string t
-                | Some i -> bracket i (tm_to_string t)
-              in
-              (Printf.sprintf "%s %s" str arg, x + 1)
-          | (t, false) :: s ->
-              let str, x = print s in
-              let str =
-                if !Settings.print_explicit_substitutions then
-                  Printf.sprintf "%s %s" str (tm_to_string t)
-                else str
-              in
-              (str, x + 1)
-          | [] -> ("", 0)
-        in
-        fst (print s)
 
-      and sub_to_string ?(func = []) sub =
-        match func with
-        | [] -> (sub_to_string_nofunc sub, false)
-        | func :: _ ->
-            let s, b = sub_to_string_func sub func in
-            (" " ^ s, b)
+module Make (Core : Core.S) = struct
+  open Core
+  module Unchecked = Unchecked.Make (Core)
 
-      and sub_to_string_nofunc sub =
-        match sub with
+  module Regular = struct
+    let rec func_to_string func =
+      let rec print_list = function
         | [] -> ""
-        | (_, (t, expl)) :: s ->
-            if expl || !Settings.print_explicit_substitutions then
-              Printf.sprintf "%s %s" (sub_to_string_nofunc s) (tm_to_string t)
-            else sub_to_string_nofunc s
-
-      and sub_to_string_func s func =
-        let arg_to_string t b =
-          if b || !Settings.print_explicit_substitutions then tm_to_string t
-          else "_"
-        in
-        let rec string_list s needs_expl skip =
-          match s with
-          | [] when skip <= 0 -> ([], needs_expl)
-          | (x, (t, e)) :: s when skip <= 0 -> (
-              match List.assoc_opt x func with
-              | None ->
-                  let l, b = string_list s needs_expl 0 in
-                  ((arg_to_string t e, e) :: l, b)
-              | Some i ->
-                  let l, b = string_list s (needs_expl || not e) (2 * i) in
-                  ((bracket i (arg_to_string t e), e) :: l, b))
-          | _ :: s -> string_list s needs_expl (skip - 1)
-          | [] ->
-              Error.fatal
-                "functorialised arguments present in inconsistent places"
-        in
-        let str, needs_expl = string_list s false 0 in
-        let str =
-          List.rev_map
-            (fun (tm, e) -> if e || needs_expl then Some tm else None)
-            str
-        in
-        (String.concat " " (List.filter_map Fun.id str), needs_expl)
+        | [ (x, n) ] -> Printf.sprintf "(%s,%d)" (Var.to_string x) n
+        | (x, n) :: l ->
+            Printf.sprintf "%s (%s,%d)" (print_list l) (Var.to_string x) n
+      in
+      match func with
+      | [] -> ""
+      | l :: func ->
+          Printf.sprintf "%s[%s]" (func_to_string func) (print_list l)
+
+    let rec bracket i s =
+      if i <= 0 then s else Printf.sprintf "[%s]" (bracket (i - 1) s)
+
+    let rec ps_to_string = function
+      | Br l ->
+          Printf.sprintf "[%s]"
+            (List.fold_left
+               (fun s ps -> Printf.sprintf "%s%s" (ps_to_string ps) s)
+               "" l)
+
+    let rec ty_to_string = function
+      | Meta_ty i -> Printf.sprintf "_ty%i" i
+      | Obj -> "*"
+      | Arr (a, u, v) ->
+          if !Settings.verbosity >= 3 then
+            Printf.sprintf "%s | %s -> %s" (ty_to_string a) (tm_to_string u)
+              (tm_to_string v)
+          else Printf.sprintf "%s -> %s" (tm_to_string u) (tm_to_string v)
+
+    and tm_to_string = function
+      | Var v -> Var.to_string v
+      | Meta_tm i -> Printf.sprintf "_tm%i" i
+      | Coh (c, s) ->
+          if !Settings.unroll_coherences then
+            Printf.sprintf "%s[%s]" (Coh.to_string c) (sub_ps_to_string s)
+          else
+            let func = Coh.func_data c in
+            Printf.sprintf "(%s%s)" (Coh.to_string c) (sub_ps_to_string ~func s)
+      | App (t, s) -> (
+          match Tm.name t with
+          | Some name ->
+              let func = Tm.func_data t in
+              let str_s, expl = sub_to_string ?func s in
+              let expl_str = if expl then "@" else "" in
+              Printf.sprintf "(%s%s%s)" expl_str name str_s
+          | None -> tm_to_string (Unchecked.tm_apply_sub (Tm.develop t) s))
+
+    and sub_ps_to_string ?(func = []) s =
+      match func with
+      | [] -> sub_ps_to_string_nofunc s
+      | func :: _ -> sub_ps_to_string_func s func
+
+    and sub_ps_to_string_nofunc s =
+      match s with
+      | [] -> ""
+      | (t, expl) :: s ->
+          if expl || !Settings.print_explicit_substitutions then
+            Printf.sprintf "%s %s" (sub_ps_to_string s) (tm_to_string t)
+          else sub_ps_to_string s
+
+    and sub_ps_to_string_func s func =
+      let rec print s =
+        match s with
+        | (t, true) :: s ->
+            let str, x = print s in
+            let arg =
+              match List.assoc_opt (Var.Db x) func with
+              | None -> tm_to_string t
+              | Some i -> bracket i (tm_to_string t)
+            in
+            (Printf.sprintf "%s %s" str arg, x + 1)
+        | (t, false) :: s ->
+            let str, x = print s in
+            let str =
+              if !Settings.print_explicit_substitutions then
+                Printf.sprintf "%s %s" str (tm_to_string t)
+              else str
+            in
+            (str, x + 1)
+        | [] -> ("", 0)
+      in
+      fst (print s)
+
+    and sub_to_string ?(func = []) sub =
+      match func with
+      | [] -> (sub_to_string_nofunc sub, false)
+      | func :: _ ->
+          let s, b = sub_to_string_func sub func in
+          (" " ^ s, b)
+
+    and sub_to_string_nofunc sub =
+      match sub with
+      | [] -> ""
+      | (_, (t, expl)) :: s ->
+          if expl || !Settings.print_explicit_substitutions then
+            Printf.sprintf "%s %s" (sub_to_string_nofunc s) (tm_to_string t)
+          else sub_to_string_nofunc s
+
+    and sub_to_string_func s func =
+      let arg_to_string t b =
+        if b || !Settings.print_explicit_substitutions then tm_to_string t
+        else "_"
+      in
+      let rec string_list s needs_expl skip =
+        match s with
+        | [] when skip <= 0 -> ([], needs_expl)
+        | (x, (t, e)) :: s when skip <= 0 -> (
+            match List.assoc_opt x func with
+            | None ->
+                let l, b = string_list s needs_expl 0 in
+                ((arg_to_string t e, e) :: l, b)
+            | Some i ->
+                let l, b = string_list s (needs_expl || not e) (2 * i) in
+                ((bracket i (arg_to_string t e), e) :: l, b))
+        | _ :: s -> string_list s needs_expl (skip - 1)
+        | [] ->
+            Error.fatal
+              "functorialised arguments present in inconsistent places"
+      in
+      let str, needs_expl = string_list s false 0 in
+      let str =
+        List.rev_map
+          (fun (tm, e) -> if e || needs_expl then Some tm else None)
+          str
+      in
+      (String.concat " " (List.filter_map Fun.id str), needs_expl)
+
+    and sub_to_string_debug sub =
+      match sub with
+      | [] -> ""
+      | (x, (t, _)) :: s ->
+          Printf.sprintf "%s (%s, %s)" (sub_to_string_debug s) (Var.to_string x)
+            (tm_to_string t)
+
+    let pp_data_to_string ?(print_func = false) (name, susp, func) =
+      let susp_name =
+        if susp > 0 then Printf.sprintf "!%i%s" susp name else name
+      in
+      match func with
+      | [] -> susp_name
+      | _ :: [] when not print_func -> susp_name
+      | _ :: func when not print_func ->
+          susp_name ^ "_func" ^ func_to_string func
+      | func -> susp_name ^ "_func" ^ func_to_string func
+
+    let rec ctx_to_string = function
+      | [] -> ""
+      | (x, (t, true)) :: c ->
+          Printf.sprintf "%s (%s: %s)" (ctx_to_string c) (Var.to_string x)
+            (ty_to_string t)
+      | (x, (t, false)) :: c ->
+          Printf.sprintf "%s {%s: %s}" (ctx_to_string c) (Var.to_string x)
+            (ty_to_string t)
+
+    let rec meta_ctx_to_string = function
+      | [] -> ""
+      | (i, t) :: c ->
+          Printf.sprintf "%s (_tm%i: %s)" (meta_ctx_to_string c) i
+            (ty_to_string t)
+
+    let full_name name = pp_data_to_string ~print_func:true name
+  end
 
-      and sub_to_string_debug sub =
-        match sub with
-        | [] -> ""
-        | (x, (t, _)) :: s ->
-            Printf.sprintf "%s (%s, %s)" (sub_to_string_debug s)
-              (Var.to_string x) (tm_to_string t)
+  module Kolmogorov = struct
+    type value = Tm of Tm.t | Coh of Coh.t
+
+    let counter = ref 0
+
+    let new_name () =
+      incr counter;
+      Printf.sprintf "tm_%i" !counter
+
+    let find t decls =
+      let rec find t decls =
+        match (t, decls) with
+        | _, [] -> None
+        | Tm t, (Tm u, n) :: _ when Tm.is_equal t u -> Some n
+        | Coh c1, (Coh c2, n) :: _ when Coh.is_equal c1 c2 -> Some n
+        | _, _ :: decls -> find t decls
+      in
+      find t decls
+
+    let rec collect_decls_ty decls = function
+      | Meta_ty _ -> assert false
+      | Obj -> decls
+      | Arr (_, u, v) ->
+          let decls = collect_decls_tm decls u in
+          collect_decls_tm decls v
+
+    and collect_decls_tm decls = function
+      | Var _ -> decls
+      | Meta_tm _ -> assert false
+      | Coh (c, s) ->
+          let decls =
+            match find (Coh c) decls with
+            | Some _ -> decls
+            | None ->
+                let _, _, pp_data = Coh.forget c in
+                let name = Regular.full_name pp_data in
+                let decls = (Coh c, name) :: decls in
+                collect_decls_coh decls c
+          in
+          collect_decls_sub_ps decls s
+      | App (t, s) ->
+          let decls =
+            match find (Tm t) decls with
+            | Some _ -> decls
+            | None ->
+                let name =
+                  match Tm.full_name t with
+                  | Some name -> name
+                  | None -> new_name ()
+                in
+                let decls = (Tm t, name) :: decls in
+                collect_decls_checkedtm decls t
+          in
+          collect_decls_sub decls s
 
-      let pp_data_to_string ?(print_func = false) (name, susp, func) =
-        let susp_name =
-          if susp > 0 then Printf.sprintf "!%i%s" susp name else name
-        in
-        match func with
-        | [] -> susp_name
-        | _ :: [] when not print_func -> susp_name
-        | _ :: func when not print_func ->
-            susp_name ^ "_func" ^ func_to_string func
-        | func -> susp_name ^ "_func" ^ func_to_string func
-
-      let rec ctx_to_string = function
-        | [] -> ""
-        | (x, (t, true)) :: c ->
-            Printf.sprintf "%s (%s: %s)" (ctx_to_string c) (Var.to_string x)
-              (ty_to_string t)
-        | (x, (t, false)) :: c ->
-            Printf.sprintf "%s {%s: %s}" (ctx_to_string c) (Var.to_string x)
-              (ty_to_string t)
-
-      let rec meta_ctx_to_string = function
-        | [] -> ""
-        | (i, t) :: c ->
-            Printf.sprintf "%s (_tm%i: %s)" (meta_ctx_to_string c) i
-              (ty_to_string t)
+    and collect_decls_checkedtm decls t =
+      let decls = collect_decls_tm decls (Tm.develop t) in
+      collect_decls_ctx decls (Tm.ctx t)
 
-      let full_name name = pp_data_to_string ~print_func:true name
-    end
+    and collect_decls_coh decls c =
+      let _, ty, _ = Coh.forget c in
+      collect_decls_ty decls ty
 
-    module Kolmogorov = struct
-      type value = Tm of TmT.t | Coh of CohT.t
+    and collect_decls_sub_ps decls = function
+      | [] -> decls
+      | (t, expl) :: s ->
+          if expl then
+            let decls = collect_decls_tm decls t in
+            collect_decls_sub_ps decls s
+          else collect_decls_sub_ps decls s
 
-      let counter = ref 0
+    and collect_decls_sub decls s = collect_decls_sub_ps decls (List.map snd s)
 
-      let new_name () =
-        incr counter;
-        Printf.sprintf "tm_%i" !counter
+    and collect_decls_ctx decls = function
+      | [] -> decls
+      | (_, (ty, _)) :: ctx -> collect_decls_ctx (collect_decls_ty decls ty) ctx
 
-      let find t decls =
-        let rec find t decls =
-          match (t, decls) with
-          | _, [] -> None
-          | Tm t, (Tm u, n) :: _ when Tm.is_equal t u -> Some n
-          | Coh c1, (Coh c2, n) :: _ when Coh.is_equal c1 c2 -> Some n
-          | _, _ :: decls -> find t decls
+    let order_decls decls =
+      let all_deps_done t ordered =
+        let deps =
+          match t with
+          | Tm t -> collect_decls_checkedtm [] t
+          | Coh c -> collect_decls_coh [] c
         in
-        find t decls
-
-      let rec collect_decls_ty decls = function
-        | Meta_ty _ -> assert false
-        | Obj -> decls
-        | Arr (_, u, v) ->
-            let decls = collect_decls_tm decls u in
-            collect_decls_tm decls v
-
-      and collect_decls_tm decls = function
-        | Var _ -> decls
-        | Meta_tm _ -> assert false
-        | Coh (c, s) ->
-            let decls =
-              match find (Coh c) decls with
-              | Some _ -> decls
-              | None ->
-                  let _, _, pp_data = Coh.forget c in
-                  let name = Regular.full_name pp_data in
-                  let decls = (Coh c, name) :: decls in
-                  collect_decls_coh decls c
-            in
-            collect_decls_sub_ps decls s
-        | App (t, s) ->
-            let decls =
-              match find (Tm t) decls with
-              | Some _ -> decls
-              | None ->
-                  let name =
-                    match Tm.full_name t with
-                    | Some name -> name
-                    | None -> new_name ()
-                  in
-                  let decls = (Tm t, name) :: decls in
-                  collect_decls_checkedtm decls t
-            in
-            collect_decls_sub decls s
-
-      and collect_decls_checkedtm decls t =
-        let decls = collect_decls_tm decls (Tm.develop t) in
-        collect_decls_ctx decls (Tm.ctx t)
-
-      and collect_decls_coh decls c =
-        let _, ty, _ = Coh.forget c in
-        collect_decls_ty decls ty
-
-      and collect_decls_sub_ps decls = function
-        | [] -> decls
-        | (t, expl) :: s ->
-            if expl then
-              let decls = collect_decls_tm decls t in
-              collect_decls_sub_ps decls s
-            else collect_decls_sub_ps decls s
-
-      and collect_decls_sub decls s =
-        collect_decls_sub_ps decls (List.map snd s)
-
-      and collect_decls_ctx decls = function
-        | [] -> decls
-        | (_, (ty, _)) :: ctx ->
-            collect_decls_ctx (collect_decls_ty decls ty) ctx
-
-      let order_decls decls =
-        let all_deps_done t ordered =
-          let deps =
-            match t with
-            | Tm t -> collect_decls_checkedtm [] t
-            | Coh c -> collect_decls_coh [] c
+        List.for_all
+          (fun (m, _) ->
+            List.exists
+              (fun (n, _) ->
+                match (n, m) with
+                | Tm t1, Tm t2 -> Tm.is_equal t1 t2
+                | Coh c1, Coh c2 -> Coh.is_equal c1 c2
+                | _, _ -> false)
+              ordered)
+          deps
+      in
+      let rec add_next decls ordered front =
+        match decls with
+        | [] -> assert false
+        | (t, n) :: decls when all_deps_done t ordered ->
+            (List.append front decls, (t, n) :: ordered)
+        | (t, n) :: decls -> add_next decls ordered ((t, n) :: front)
+      in
+      let rec add_recursively decls ordered =
+        match decls with
+        | [] -> ordered
+        | _ ->
+            let decls, ordered = add_next decls ordered [] in
+            add_recursively decls ordered
+      in
+      add_recursively decls []
+
+    let rec ty_to_string decls = function
+      | Meta_ty _ -> assert false
+      | Obj -> "*"
+      | Arr (_, u, v) ->
+          let u = tm_to_string decls u in
+          let v = tm_to_string decls v in
+          Printf.sprintf "%s -> %s" u v
+
+    and tm_to_string decls t =
+      match t with
+      | Var v -> Var.to_string v
+      | Meta_tm _ -> assert false
+      | Coh (c, s) ->
+          let c =
+            match find (Coh c) decls with Some c -> c | None -> assert false
           in
-          List.for_all
-            (fun (m, _) ->
-              List.exists
-                (fun (n, _) ->
-                  match (n, m) with
-                  | Tm t1, Tm t2 -> Tm.is_equal t1 t2
-                  | Coh c1, Coh c2 -> Coh.is_equal c1 c2
-                  | _, _ -> false)
-                ordered)
-            deps
-        in
-        let rec add_next decls ordered front =
-          match decls with
-          | [] -> assert false
-          | (t, n) :: decls when all_deps_done t ordered ->
-              (List.append front decls, (t, n) :: ordered)
-          | (t, n) :: decls -> add_next decls ordered ((t, n) :: front)
-        in
-        let rec add_recursively decls ordered =
-          match decls with
-          | [] -> ordered
-          | _ ->
-              let decls, ordered = add_next decls ordered [] in
-              add_recursively decls ordered
-        in
-        add_recursively decls []
-
-      let rec ty_to_string decls = function
-        | Meta_ty _ -> assert false
-        | Obj -> "*"
-        | Arr (_, u, v) ->
-            let u = tm_to_string decls u in
-            let v = tm_to_string decls v in
-            Printf.sprintf "%s -> %s" u v
-
-      and tm_to_string decls t =
-        match t with
-        | Var v -> Var.to_string v
-        | Meta_tm _ -> assert false
-        | Coh (c, s) ->
-            let c =
-              match find (Coh c) decls with Some c -> c | None -> assert false
-            in
+          let s = sub_ps_to_string decls s in
+          Printf.sprintf "%s %s" c s
+      | App (t, s) ->
+          let t =
+            match find (Tm t) decls with Some t -> t | None -> assert false
+          in
+          let s = sub_to_string decls s in
+          Printf.sprintf "%s %s" t s
+
+    and sub_ps_to_string decls s =
+      match s with
+      | [] -> ""
+      | (t, expl) :: s ->
+          if expl then
+            let t = tm_to_string decls t in
             let s = sub_ps_to_string decls s in
-            Printf.sprintf "%s %s" c s
-        | App (t, s) ->
-            let t =
-              match find (Tm t) decls with Some t -> t | None -> assert false
+            Printf.sprintf "%s (%s)" s t
+          else sub_ps_to_string decls s
+
+    and sub_to_string decls s = sub_ps_to_string decls (List.map snd s)
+
+    let print_tm_in_ctx decls ctx tm =
+      let rec print decls ctx res =
+        match ctx with
+        | [] -> "λ" ^ res
+        | (x, (ty, true)) :: ctx ->
+            let ty = ty_to_string decls ty in
+            let res = Printf.sprintf "(%s,%s) %s" (Var.to_string x) ty res in
+            print decls ctx res
+        | (x, (ty, false)) :: ctx ->
+            let ty = ty_to_string decls ty in
+            let res = Printf.sprintf "{%s,%s} %s" (Var.to_string x) ty res in
+            print decls ctx res
+      in
+      print decls ctx (Printf.sprintf "=> %s" tm)
+
+    let print_tm t =
+      let rec print_decls decls res =
+        match decls with
+        | [] -> res
+        | (Tm t, name) :: decls ->
+            let ctx = Tm.ctx t in
+            let newtm = tm_to_string decls (Tm.develop t) in
+            let newdecl = print_tm_in_ctx decls ctx newtm in
+            let res = Printf.sprintf "let %s = %s in \n %s" name newdecl res in
+            print_decls decls res
+        | (Coh c, name) :: decls ->
+            let ps, ty, _ = Coh.forget c in
+            let res =
+              Printf.sprintf "let %s = Coh(%s, %s) in\n %s" name
+                (Regular.ps_to_string ps) (ty_to_string decls ty) res
             in
-            let s = sub_to_string decls s in
-            Printf.sprintf "%s %s" t s
-
-      and sub_ps_to_string decls s =
-        match s with
-        | [] -> ""
-        | (t, expl) :: s ->
-            if expl then
-              let t = tm_to_string decls t in
-              let s = sub_ps_to_string decls s in
-              Printf.sprintf "%s (%s)" s t
-            else sub_ps_to_string decls s
-
-      and sub_to_string decls s = sub_ps_to_string decls (List.map snd s)
-
-      let print_tm_in_ctx decls ctx tm =
-        let rec print decls ctx res =
-          match ctx with
-          | [] -> "λ" ^ res
-          | (x, (ty, true)) :: ctx ->
-              let ty = ty_to_string decls ty in
-              let res = Printf.sprintf "(%s,%s) %s" (Var.to_string x) ty res in
-              print decls ctx res
-          | (x, (ty, false)) :: ctx ->
-              let ty = ty_to_string decls ty in
-              let res = Printf.sprintf "{%s,%s} %s" (Var.to_string x) ty res in
-              print decls ctx res
-        in
-        print decls ctx (Printf.sprintf "=> %s" tm)
-
-      let print_tm t =
-        let rec print_decls decls res =
-          match decls with
-          | [] -> res
-          | (Tm t, name) :: decls ->
-              let ctx = Tm.ctx t in
-              let newtm = tm_to_string decls (Tm.develop t) in
-              let newdecl = print_tm_in_ctx decls ctx newtm in
-              let res =
-                Printf.sprintf "let %s = %s in \n %s" name newdecl res
-              in
-              print_decls decls res
-          | (Coh c, name) :: decls ->
-              let ps, ty, _ = Coh.forget c in
-              let res =
-                Printf.sprintf "let %s = Coh(%s, %s) in\n %s" name
-                  (Regular.ps_to_string ps) (ty_to_string decls ty) res
-              in
-              print_decls decls res
-        in
-        let decls = collect_decls_tm [] t in
-        let decls = order_decls decls in
-        let res = tm_to_string decls t in
-        print_decls decls res
-    end
-
-    let ps_to_string = Regular.ps_to_string
-    let ty_to_string = Regular.ty_to_string
-    let tm_to_string = Regular.tm_to_string
-    let ctx_to_string = Regular.ctx_to_string
-    let sub_ps_to_string = Regular.sub_ps_to_string
-    let sub_to_string ?func s = fst (Regular.sub_to_string ?func s)
-    let sub_to_string_debug = Regular.sub_to_string_debug
-    let meta_ctx_to_string = Regular.meta_ctx_to_string
-    let pp_data_to_string = Regular.pp_data_to_string
-    let full_name = Regular.full_name
-    let print_kolmogorov = Kolmogorov.print_tm
+            print_decls decls res
+      in
+      let decls = collect_decls_tm [] t in
+      let decls = order_decls decls in
+      let res = tm_to_string decls t in
+      print_decls decls res
   end
+
+  let ps_to_string = Regular.ps_to_string
+  let ty_to_string = Regular.ty_to_string
+  let tm_to_string = Regular.tm_to_string
+  let ctx_to_string = Regular.ctx_to_string
+  let sub_ps_to_string = Regular.sub_ps_to_string
+  let sub_to_string ?func s = fst (Regular.sub_to_string ?func s)
+  let sub_to_string_debug = Regular.sub_to_string_debug
+  let meta_ctx_to_string = Regular.meta_ctx_to_string
+  let pp_data_to_string = Regular.pp_data_to_string
+  let full_name = Regular.full_name
+  let print_kolmogorov = Kolmogorov.print_tm
 end
diff --git a/lib/internals/printing.mli b/lib/internals/printing.mli
index 10666a0d..72d78c17 100644
--- a/lib/internals/printing.mli
+++ b/lib/internals/printing.mli
@@ -1,30 +1,22 @@
-open Common
-open Unchecked_types
+module Make (Core : Core.S) : sig
+  open Core
+  open Common
 
-module Printing (Coh : sig
-  type t
-end) (Tm : sig
-  type t
-end) (_ : sig
-  val tm_apply_sub :
-    Unchecked_types(Coh)(Tm).tm ->
-    Unchecked_types(Coh)(Tm).sub ->
-    Unchecked_types(Coh)(Tm).tm
-end) : sig
-  open Unchecked_types(Coh)(Tm)
-  open Signatures.Signatures(Coh)(Tm)
+  val ps_to_string : ps -> string
+  val ty_to_string : (Coh.t, Tm.t) ty -> string
+  val tm_to_string : (Coh.t, Tm.t) tm -> string
 
-  module Make (_ : sig
-    val to_string : ?unroll:bool -> Coh.t -> string
-    val func_data : Coh.t -> (Var.t * int) list list
-    val forget : Coh.t -> ps * ty * pp_data
-    val is_equal : Coh.t -> Coh.t -> bool
-  end) (_ : sig
-    val func_data : Tm.t -> (Var.t * int) list list option
-    val name : Tm.t -> string option
-    val full_name : Tm.t -> string option
-    val develop : Tm.t -> tm
-    val ctx : Tm.t -> ctx
-    val is_equal : Tm.t -> Tm.t -> bool
-  end) : PrintingS
+  val sub_ps_to_string :
+    ?func:(Var.t * int) list list -> (Coh.t, Tm.t) sub_ps -> string
+
+  val ctx_to_string : (Coh.t, Tm.t) ctx -> string
+
+  val sub_to_string :
+    ?func:(Var.t * int) list list -> (Coh.t, Tm.t) sub -> string
+
+  val sub_to_string_debug : (Coh.t, Tm.t) sub -> string
+  val meta_ctx_to_string : (Coh.t, Tm.t) meta_ctx -> string
+  val full_name : pp_data -> string
+  val pp_data_to_string : ?print_func:bool -> pp_data -> string
+  val print_kolmogorov : (Coh.t, Tm.t) tm -> string
 end
diff --git a/lib/internals/signatures.mli b/lib/internals/signatures.mli
deleted file mode 100644
index b95cb324..00000000
--- a/lib/internals/signatures.mli
+++ /dev/null
@@ -1,106 +0,0 @@
-open Common
-open Unchecked_types
-
-module Signatures (Coh : sig
-  type t
-end) (Tm : sig
-  type t
-end) : sig
-  open Unchecked_types(Coh)(Tm)
-
-  module type UncheckedS = sig
-    type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
-
-    val dim_ctx : ctx -> int
-    val dim_ty : ty -> int
-    val dim_ps : ps -> int
-    val ps_to_ctx : ps -> ctx
-    val identity_ps : ps -> sub_ps
-    val tm_apply_sub : tm -> sub -> tm
-    val ty_apply_sub : ty -> sub -> ty
-    val sub_apply_sub : sub -> sub -> sub
-    val sub_ps_apply_sub : sub_ps -> sub -> sub_ps
-    val ty_apply_sub_ps : ty -> sub_ps -> ty
-    val tm_apply_sub_ps : tm -> sub_ps -> tm
-    val sub_ps_apply_sub_ps : sub_ps -> sub_ps -> sub_ps
-    val ty_rename : ty -> (Var.t * tm) list -> ty
-    val tm_rename : tm -> (Var.t * tm) list -> tm
-    val sub_ps_rename : sub_ps -> (Var.t * tm) list -> sub_ps
-    val ty_sub_preimage : ty -> sub -> ty
-    val db_levels : ctx -> ctx * (Var.t * (int * bool)) list * int
-    val db_level_sub : ctx -> sub
-    val db_level_sub_inv : ctx -> sub
-    val rename_ty : ty -> (Var.t * (int * bool)) list -> ty
-    val rename_tm : tm -> (Var.t * (int * bool)) list -> tm
-    val tm_contains_var : tm -> Var.t -> bool
-    val ty_contains_var : ty -> Var.t -> bool
-    val tm_contains_vars : tm -> Var.t list -> bool
-    val sub_ps_to_sub : sub_ps -> sub
-    val sub_to_sub_ps : sub -> sub_ps
-    val suspend_pp_data : pp_data -> pp_data
-    val suspend_ps : ps -> ps
-    val suspend_ty : ty -> ty
-    val suspend_tm : tm -> tm
-    val suspend_ctx : ctx -> ctx
-    val suspend_sub_ps : sub_ps -> sub_ps
-    val suspend_sub : sub -> sub
-    val ps_bdry : ps -> ps
-    val ps_src : ps -> sub_ps
-    val ps_tgt : ps -> sub_ps
-    val tm_sub_preimage : tm -> sub -> tm
-    val suspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
-    val opsuspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
-    val canonical_inclusions : ps list -> sub_ps list
-    val ty_to_sub_ps : ty -> sub_ps
-    val coh_to_sub_ps : tm -> sub_ps
-    val ps_compose : int -> ps -> ps -> ps * sub_ps * sub_ps
-    val pullback_up : int -> ps -> ps -> sub_ps -> sub_ps -> sub_ps
-    val sub_ps_to_sub_ps_bp : sub_ps -> sub_ps_bp
-    val wedge_sub_ps_bp : sub_ps_bp list -> sub_ps
-    val list_to_sub : tm list -> ctx -> sub
-    val list_to_db_level_sub : tm list -> (Var.t * tm) list
-    val identity : ctx -> sub
-    val disc : int -> ps
-    val disc_ctx : int -> ctx
-    val disc_type : int -> ty
-    val sphere : int -> ctx
-    val sphere_inc : int -> sub
-    val disc_src : int -> sub_ps
-    val disc_tgt : int -> sub_ps
-    val develop_tm : tm -> tm
-    val develop_ty : ty -> ty
-  end
-
-  module type PrintingS = sig
-    val ps_to_string : ps -> string
-    val ty_to_string : ty -> string
-    val tm_to_string : tm -> string
-    val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
-    val ctx_to_string : ctx -> string
-    val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
-    val sub_to_string_debug : sub -> string
-    val meta_ctx_to_string : meta_ctx -> string
-    val full_name : pp_data -> string
-    val pp_data_to_string : ?print_func:bool -> pp_data -> string
-    val print_kolmogorov : tm -> string
-  end
-
-  module type EqualityS = sig
-    val check_equal_ctx : ctx -> ctx -> unit
-    val check_equal_ps : ps -> ps -> unit
-    val check_equal_ty : ty -> ty -> unit
-    val check_equal_tm : tm -> tm -> unit
-    val check_equal_sub_ps : sub_ps -> sub_ps -> unit
-    val is_equal_ctx : ctx -> ctx -> bool
-    val is_equal_ps : ps -> ps -> bool
-    val is_equal_ty : ty -> ty -> bool
-    val is_equal_tm : tm -> tm -> bool
-  end
-
-  module type DisplayMapsS = sig
-    val var_apply_sub : Var.t -> sub -> Var.t
-    val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
-    val glue : sub -> sub -> sub -> ctx -> sub -> sub
-    val pp_data_rename : pp_data -> sub -> pp_data
-  end
-end
diff --git a/lib/internals/syntax.ml b/lib/internals/syntax.ml
index c619992b..5b03c1e4 100644
--- a/lib/internals/syntax.ml
+++ b/lib/internals/syntax.ml
@@ -1,44 +1,16 @@
-open Common
-open Unchecked_types
+module Make (Core : Core.S) = struct
+  open Core
 
-module Syntax (CohT : sig
-  type t
-end) (TmT : sig
-  type t
-end) =
-struct
-  open Unchecked_types (CohT) (TmT)
+  type ty = (Coh.t, Tm.t) Common.ty
+  type tm = (Coh.t, Tm.t) Common.tm
+  type sub_ps = (Coh.t, Tm.t) Common.sub_ps
+  type sub = (Coh.t, Tm.t) Common.sub
+  type ctx = (Coh.t, Tm.t) Common.ctx
+  type meta_ctx = (Coh.t, Tm.t) Common.meta_ctx
+  type constr = (Coh.t, Tm.t) Common.constr
 
-  module Make (Coh : sig
-    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
-    val check : ps -> ty -> pp_data -> CohT.t
-    val to_string : ?unroll:bool -> CohT.t -> string
-    val func_data : CohT.t -> (Var.t * int) list list
-    val is_equal : CohT.t -> CohT.t -> bool
-  end) (Tm : sig
-    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
-    val func_data : TmT.t -> (Var.t * int) list list option
-    val name : TmT.t -> string option
-    val full_name : TmT.t -> string option
-    val ctx : TmT.t -> ctx
-    val is_equal : TmT.t -> TmT.t -> bool
-
-    val apply :
-      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
-      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
-      (pp_data -> pp_data) ->
-      TmT.t ->
-      TmT.t * Unchecked_types(CohT)(TmT).sub
-  end) =
-  struct
-    include Unchecked_types (CohT) (TmT)
-    module U = Unchecked.Unchecked (CohT) (TmT)
-    module Unchecked = U.Make (Coh) (Tm)
-    module D = Display_maps.DisplayMaps (CohT) (TmT)
-    module Display_maps = D.Make (Coh) (Tm)
-    module P = Printing.Printing (CohT) (TmT) (Unchecked)
-    module Printing = P.Make (Coh) (Tm)
-    module E = Equality.Equality (CohT) (TmT)
-    module Equality = E.Make (Coh) (Tm)
-  end
+  module Unchecked = Unchecked.Make (Core)
+  module Display_maps = Display_maps.Make (Core)
+  module Printing = Printing.Make (Core)
+  module Equality = Equality.Make (Core)
 end
diff --git a/lib/internals/syntax.mli b/lib/internals/syntax.mli
index 4374d1a3..471e4cea 100644
--- a/lib/internals/syntax.mli
+++ b/lib/internals/syntax.mli
@@ -1,46 +1,16 @@
-open Unchecked_types
-open Signatures
-open Common
+module Make : functor (Core : Core.S) -> sig
+  open Core
 
-module Syntax : functor
-  (CohT : sig
-     type t
-   end)
-  (TmT : sig
-     type t
-   end)
-  -> sig
-  open Unchecked_types(CohT)(TmT)
-  open Signatures(CohT)(TmT)
+  type ty = (Coh.t, Tm.t) Common.ty
+  type tm = (Coh.t, Tm.t) Common.tm
+  type sub_ps = (Coh.t, Tm.t) Common.sub_ps
+  type sub = (Coh.t, Tm.t) Common.sub
+  type ctx = (Coh.t, Tm.t) Common.ctx
+  type meta_ctx = (Coh.t, Tm.t) Common.meta_ctx
+  type constr = (Coh.t, Tm.t) Common.constr
 
-  module Make : functor
-    (_ : sig
-       val forget : CohT.t -> ps * ty * pp_data
-       val check : ps -> ty -> pp_data -> CohT.t
-       val to_string : ?unroll:bool -> CohT.t -> string
-       val func_data : CohT.t -> (Var.t * int) list list
-       val is_equal : CohT.t -> CohT.t -> bool
-     end)
-    (_ : sig
-       val develop : TmT.t -> tm
-       val func_data : TmT.t -> (Var.t * int) list list option
-       val name : TmT.t -> string option
-       val full_name : TmT.t -> string option
-       val ctx : TmT.t -> ctx
-       val is_equal : TmT.t -> TmT.t -> bool
-
-       val apply :
-         (ctx -> ctx) ->
-         (tm -> tm) ->
-         (pp_data -> pp_data) ->
-         TmT.t ->
-         TmT.t * sub
-     end)
-    -> sig
-    include module type of Unchecked_types (CohT) (TmT)
-    module Unchecked : UncheckedS
-    module Display_maps : DisplayMapsS
-    module Printing : PrintingS
-    module Equality : EqualityS
-  end
+  module Unchecked : module type of Unchecked.Make (Core)
+  module Display_maps : module type of Display_maps.Make (Core)
+  module Printing : module type of Printing.Make (Core)
+  module Equality : module type of Equality.Make (Core)
 end
diff --git a/lib/internals/unchecked.ml b/lib/internals/unchecked.ml
index 9c899459..7b762dc9 100644
--- a/lib/internals/unchecked.ml
+++ b/lib/internals/unchecked.ml
@@ -1,130 +1,108 @@
 open Std
 open Common
-open Unchecked_types
-
-module Unchecked (CohT : sig
-  type t
-end) (TmT : sig
-  type t
-end) =
-struct
-  open Unchecked_types (CohT) (TmT)
-
-  module Make (Coh : sig
-    val forget : CohT.t -> ps * Unchecked_types(CohT)(TmT).ty * pp_data
-    val check : ps -> ty -> pp_data -> CohT.t
-  end) (Tm : sig
-    val develop : TmT.t -> Unchecked_types(CohT)(TmT).tm
-
-    val apply :
-      (Unchecked_types(CohT)(TmT).ctx -> Unchecked_types(CohT)(TmT).ctx) ->
-      (Unchecked_types(CohT)(TmT).tm -> Unchecked_types(CohT)(TmT).tm) ->
-      (pp_data -> pp_data) ->
-      TmT.t ->
-      TmT.t * Unchecked_types(CohT)(TmT).sub
-  end) =
-  struct
-    let sub_ps_to_sub s =
-      let rec aux s =
-        match s with
-        | [] -> ([], 0)
-        | (t, e) :: s ->
-            let s, i = aux s in
-            ((Var.Db i, (t, e)) :: s, i + 1)
-      in
-      fst (aux s)
-
-    let sub_to_sub_ps s = List.map snd s
-
-    let rec tm_do_on_variables tm f =
-      match tm with
-      | Var v -> f v
-      | Meta_tm i -> Meta_tm i
-      | Coh (c, s) -> Coh (c, sub_ps_do_on_variables s f)
-      | App (t, s) -> App (t, sub_do_on_variables s f)
-
-    and sub_do_on_variables s f =
-      List.map (fun (v, (t, e)) -> (v, (tm_do_on_variables t f, e))) s
-
-    and sub_ps_do_on_variables s f =
-      List.map (fun (t, expl) -> (tm_do_on_variables t f, expl)) s
-
-    let rec ty_do_on_variables ty f =
-      match ty with
-      | Meta_ty i -> Meta_ty i
-      | Obj -> Obj
-      | Arr (a, u, v) ->
-          Arr
-            ( ty_do_on_variables a f,
-              tm_do_on_variables u f,
-              tm_do_on_variables v f )
-
-    let var_apply_sub v s =
-      match List.assoc_opt v s with Some (t, _) -> t | None -> Var v
-
-    let tm_apply_sub tm s = tm_do_on_variables tm (fun v -> var_apply_sub v s)
-    let ty_apply_sub ty s = ty_do_on_variables ty (fun v -> var_apply_sub v s)
-
-    let sub_ps_apply_sub s1 s2 =
-      sub_ps_do_on_variables s1 (fun v -> var_apply_sub v s2)
-
-    let sub_apply_sub s1 s2 =
-      List.map (fun (v, (t, e)) -> (v, (tm_apply_sub t s2, e))) s1
-
-    let ty_apply_sub_ps ty s = ty_apply_sub ty (sub_ps_to_sub s)
-    let tm_apply_sub_ps tm s = tm_apply_sub tm (sub_ps_to_sub s)
-    let sub_ps_apply_sub_ps sub_ps s = sub_ps_apply_sub sub_ps (sub_ps_to_sub s)
-
-    let var_rename v r =
-      match List.assoc_opt v r with Some t -> t | None -> Var v
-
-    let tm_rename tm r = tm_do_on_variables tm (fun v -> var_rename v r)
-    let ty_rename ty r = ty_do_on_variables ty (fun v -> var_rename v r)
-    let sub_ps_rename s r = sub_ps_do_on_variables s (fun v -> var_rename v r)
-
-    let rec var_sub_preimage v s =
+
+module Make (Core : Core.S) = struct
+  open Core
+
+  let sub_ps_to_sub s =
+    let rec aux s =
       match s with
-      | [] -> raise NotInImage
-      | (w, (Var v', _)) :: _ when v = v' -> Var w
-      | _ :: s -> var_sub_preimage v s
-
-    let tm_sub_preimage tm s =
-      tm_do_on_variables tm (fun v -> var_sub_preimage v s)
-
-    let ty_sub_preimage ty s =
-      ty_do_on_variables ty (fun v -> var_sub_preimage v s)
-
-    (* rename is applying a variable to de Bruijn levels substitutions *)
-    let rename_var v l =
-      try Var (Db (fst (List.assoc v l)))
-      with Not_found ->
-        Error.fatal
-          (Printf.sprintf "variable %s not found in context" (Var.to_string v))
-
-    let rename_ty ty l = ty_do_on_variables ty (fun v -> rename_var v l)
-    let rename_tm tm l = tm_do_on_variables tm (fun v -> rename_var v l)
-
-    let rec db_levels c =
-      match c with
-      | [] -> ([], [], -1)
-      | (x, (t, expl)) :: c ->
-          let c, l, max = db_levels c in
-          if List.mem_assoc x l then raise (DoubledVar (Var.to_string x))
-          else
-            let lvl = max + 1 in
-            ( (Var.Db lvl, (rename_ty t l, expl)) :: c,
-              (x, (lvl, expl)) :: l,
-              lvl )
-
-    let db_level_sub c =
-      let _, names, _ = db_levels c in
-      List.map (fun (t, (n, expl)) -> (Var.Db n, (Var t, expl))) names
-
-    let db_level_sub_inv c =
-      let _, names, _ = db_levels c in
-      List.map (fun (t, (n, expl)) -> (t, (Var (Var.Db n), expl))) names
-
-    (* Definition of FreePos(B):
+      | [] -> ([], 0)
+      | (t, e) :: s ->
+          let s, i = aux s in
+          ((Var.Db i, (t, e)) :: s, i + 1)
+    in
+    fst (aux s)
+
+  let sub_to_sub_ps s = List.map snd s
+
+  let rec tm_do_on_variables tm f =
+    match tm with
+    | Var v -> f v
+    | Meta_tm i -> Meta_tm i
+    | Coh (c, s) -> Coh (c, sub_ps_do_on_variables s f)
+    | App (t, s) -> App (t, sub_do_on_variables s f)
+
+  and sub_do_on_variables s f =
+    List.map (fun (v, (t, e)) -> (v, (tm_do_on_variables t f, e))) s
+
+  and sub_ps_do_on_variables s f =
+    List.map (fun (t, expl) -> (tm_do_on_variables t f, expl)) s
+
+  let rec ty_do_on_variables ty f =
+    match ty with
+    | Meta_ty i -> Meta_ty i
+    | Obj -> Obj
+    | Arr (a, u, v) ->
+        Arr
+          ( ty_do_on_variables a f,
+            tm_do_on_variables u f,
+            tm_do_on_variables v f )
+
+  let var_apply_sub v s =
+    match List.assoc_opt v s with Some (t, _) -> t | None -> Var v
+
+  let tm_apply_sub tm s = tm_do_on_variables tm (fun v -> var_apply_sub v s)
+  let ty_apply_sub ty s = ty_do_on_variables ty (fun v -> var_apply_sub v s)
+
+  let sub_ps_apply_sub s1 s2 =
+    sub_ps_do_on_variables s1 (fun v -> var_apply_sub v s2)
+
+  let sub_apply_sub s1 s2 =
+    List.map (fun (v, (t, e)) -> (v, (tm_apply_sub t s2, e))) s1
+
+  let ty_apply_sub_ps ty s = ty_apply_sub ty (sub_ps_to_sub s)
+  let tm_apply_sub_ps tm s = tm_apply_sub tm (sub_ps_to_sub s)
+  let sub_ps_apply_sub_ps sub_ps s = sub_ps_apply_sub sub_ps (sub_ps_to_sub s)
+
+  let var_rename v r =
+    match List.assoc_opt v r with Some t -> t | None -> Var v
+
+  let tm_rename tm r = tm_do_on_variables tm (fun v -> var_rename v r)
+  let ty_rename ty r = ty_do_on_variables ty (fun v -> var_rename v r)
+  let sub_ps_rename s r = sub_ps_do_on_variables s (fun v -> var_rename v r)
+
+  let rec var_sub_preimage v s =
+    match s with
+    | [] -> raise NotInImage
+    | (w, (Var v', _)) :: _ when v = v' -> Var w
+    | _ :: s -> var_sub_preimage v s
+
+  let tm_sub_preimage tm s =
+    tm_do_on_variables tm (fun v -> var_sub_preimage v s)
+
+  let ty_sub_preimage ty s =
+    ty_do_on_variables ty (fun v -> var_sub_preimage v s)
+
+  (* rename is applying a variable to de Bruijn levels substitutions *)
+  let rename_var v l =
+    try Var (Db (fst (List.assoc v l)))
+    with Not_found ->
+      Error.fatal
+        (Printf.sprintf "variable %s not found in context" (Var.to_string v))
+
+  let rename_ty ty l = ty_do_on_variables ty (fun v -> rename_var v l)
+  let rename_tm tm l = tm_do_on_variables tm (fun v -> rename_var v l)
+
+  let rec db_levels c =
+    match c with
+    | [] -> ([], [], -1)
+    | (x, (t, expl)) :: c ->
+        let c, l, max = db_levels c in
+        if List.mem_assoc x l then raise (DoubledVar (Var.to_string x))
+        else
+          let lvl = max + 1 in
+          ((Var.Db lvl, (rename_ty t l, expl)) :: c, (x, (lvl, expl)) :: l, lvl)
+
+  let db_level_sub c =
+    let _, names, _ = db_levels c in
+    List.map (fun (t, (n, expl)) -> (Var.Db n, (Var t, expl))) names
+
+  let db_level_sub_inv c =
+    let _, names, _ = db_levels c in
+    List.map (fun (t, (n, expl)) -> (t, (Var (Var.Db n), expl))) names
+
+  (* Definition of FreePos(B):
        - in the paper, we define the bipointed verison with suspension and wedge
        - here we don't need the left point, as it is always the DeBruijn level 0,\
          however, we need the right point. We also need to rename every variable in\
@@ -134,365 +112,365 @@ struct
          maximal variable.
     *)
 
-    type ctx_bp = { ctx : ctx; max : int; rp : int }
-    type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
-
-    let suspend_ps ps = Br [ ps ]
-
-    let suspend_func_data f =
-      List.map (List.map (fun (x, i) -> (Var.suspend x, i))) f
-
-    let suspend_pp_data = function
-      | name, susp, func -> (name, susp + 1, suspend_func_data func)
-
-    let rec suspend_ty = function
-      | Obj -> Arr (Obj, Var (Db 0), Var (Db 1))
-      | Arr (a, v, u) -> Arr (suspend_ty a, suspend_tm v, suspend_tm u)
-      | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
-
-    and suspend_tm = function
-      | Var v -> Var (Var.suspend v)
-      | Coh (c, s) -> Coh (suspend_coh c, suspend_sub_ps s)
-      | App (t, s) ->
-          let t, _ = Tm.apply suspend_ctx suspend_tm suspend_pp_data t in
-          let s = sub_ps_to_sub (sub_to_sub_ps s) in
-          App (t, suspend_sub s)
-      | Meta_tm _ -> Error.fatal "meta-variables should be resolved"
-
-    and suspend_coh c =
-      let p, t, pp_data = Coh.forget c in
-      Coh.check (suspend_ps p) (suspend_ty t) (suspend_pp_data pp_data)
-
-    and suspend_sub_ps = function
-      | [] -> [ (Var (Var.Db 1), false); (Var (Var.Db 0), false) ]
-      | (t, expl) :: s -> (suspend_tm t, expl) :: suspend_sub_ps s
-
-    and suspend_sub = function
-      | [] ->
-          [
-            (Var.Db 1, (Var (Var.Db 1), false));
-            (Var.Db 0, (Var (Var.Db 0), false));
-          ]
-      | (v, (t, e)) :: s -> (Var.suspend v, (suspend_tm t, e)) :: suspend_sub s
-
-    and suspend_ctx_rp ctx =
-      match ctx with
-      | [] ->
-          let ctx = [ (Var.Db 1, (Obj, false)); (Var.Db 0, (Obj, false)) ] in
-          { ctx; max = 1; rp = 1 }
-      | (v, (t, expl)) :: c -> (
-          let c = suspend_ctx_rp c in
-          let v = Var.suspend v in
-          match v with
-          | Var.Db i ->
-              {
-                ctx = (v, (suspend_ty t, expl)) :: c.ctx;
-                max = max i c.max;
-                rp = c.rp;
-              }
-          | _ ->
-              {
-                ctx = (v, (suspend_ty t, expl)) :: c.ctx;
-                max = c.max;
-                rp = c.rp;
-              })
-
-    and suspend_ctx ctx = (suspend_ctx_rp ctx).ctx
-
-    let rec dim_ps = function Br [] -> 0 | Br l -> 1 + max_list_ps l
-
-    and max_list_ps = function
-      | [] -> 0
-      | p :: l -> max (dim_ps p) (max_list_ps l)
-
-    let var_inr_wedge v ctx_bp =
-      match v with
-      | Var.Db j -> if j = 0 then Var.Db ctx_bp.rp else Var.Db (j + ctx_bp.max)
-      | _ -> Error.fatal "expecting a de-bruijn level"
-
-    let ty_inr_wedge ty ctx_bp =
-      ty_do_on_variables ty (fun v -> Var (var_inr_wedge v ctx_bp))
-
-    let tm_inr_wedge tm ctx_bp =
-      tm_do_on_variables tm (fun v -> Var (var_inr_wedge v ctx_bp))
-
-    let rec ps_to_ctx_rp ps =
-      match ps with
-      | Br [] -> { ctx = [ (Var.Db 0, (Obj, true)) ]; rp = 0; max = 0 }
-      | Br l ->
-          let _, ctx = canonical_inclusions l in
-          ctx
-
-    and canonical_inclusions l =
-      match l with
-      | [] -> Error.fatal "empty inclusions"
-      | [ ps ] ->
-          ( [ suspend_sub_ps (identity_ps ps) ],
-            suspend_ctx_rp (ps_to_ctx_rp ps).ctx )
-      | ps :: l ->
-          let id = suspend_sub_ps (identity_ps ps) in
-          let ctx_ps = suspend_ctx_rp (ps_to_ctx_rp ps).ctx in
-          let incls, ctx_base = canonical_inclusions l in
-          let ctx_bp =
+  type ctx_bp = { ctx : (Coh.t, Tm.t) ctx; max : int; rp : int }
+
+  type sub_ps_bp = {
+    sub_ps : (Coh.t, Tm.t) sub_ps;
+    l : (Coh.t, Tm.t) tm;
+    r : (Coh.t, Tm.t) tm;
+  }
+
+  let suspend_ps ps = Br [ ps ]
+
+  let suspend_func_data f =
+    List.map (List.map (fun (x, i) -> (Var.suspend x, i))) f
+
+  let suspend_pp_data = function
+    | name, susp, func -> (name, susp + 1, suspend_func_data func)
+
+  let rec suspend_ty = function
+    | Obj -> Arr (Obj, Var (Db 0), Var (Db 1))
+    | Arr (a, v, u) -> Arr (suspend_ty a, suspend_tm v, suspend_tm u)
+    | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
+
+  and suspend_tm = function
+    | Var v -> Var (Var.suspend v)
+    | Coh (c, s) -> Coh (suspend_coh c, suspend_sub_ps s)
+    | App (t, s) ->
+        let t, _ = Tm.apply suspend_ctx suspend_tm suspend_pp_data t in
+        let s = sub_ps_to_sub (sub_to_sub_ps s) in
+        App (t, suspend_sub s)
+    | Meta_tm _ -> Error.fatal "meta-variables should be resolved"
+
+  and suspend_coh c =
+    let p, t, pp_data = Coh.forget c in
+    Coh.check (suspend_ps p) (suspend_ty t) (suspend_pp_data pp_data)
+
+  and suspend_sub_ps = function
+    | [] -> [ (Var (Var.Db 1), false); (Var (Var.Db 0), false) ]
+    | (t, expl) :: s -> (suspend_tm t, expl) :: suspend_sub_ps s
+
+  and suspend_sub = function
+    | [] ->
+        [
+          (Var.Db 1, (Var (Var.Db 1), false));
+          (Var.Db 0, (Var (Var.Db 0), false));
+        ]
+    | (v, (t, e)) :: s -> (Var.suspend v, (suspend_tm t, e)) :: suspend_sub s
+
+  and suspend_ctx_rp ctx =
+    match ctx with
+    | [] ->
+        let ctx = [ (Var.Db 1, (Obj, false)); (Var.Db 0, (Obj, false)) ] in
+        { ctx; max = 1; rp = 1 }
+    | (v, (t, expl)) :: c -> (
+        let c = suspend_ctx_rp c in
+        let v = Var.suspend v in
+        match v with
+        | Var.Db i ->
             {
-              ctx = append_onto_ctx ctx_ps ctx_base;
-              rp = ctx_ps.rp + ctx_base.max;
-              max = ctx_ps.max + ctx_base.max;
+              ctx = (v, (suspend_ty t, expl)) :: c.ctx;
+              max = max i c.max;
+              rp = c.rp;
             }
-          in
-          let incl = List.map (fun (t, e) -> (tm_inr_wedge t ctx_base, e)) id in
-          (incl :: incls, ctx_bp)
-
-    and append_onto_ctx ctx base =
-      let rec aux = function
-        | [] -> Error.fatal "empty context in wedge"
-        | [ _ ] -> base.ctx
-        | (v, (t, expl)) :: ctx ->
-            let t = ty_inr_wedge t base in
-            let v = var_inr_wedge v base in
-            (v, (t, expl)) :: aux ctx
-      in
-      aux ctx.ctx
-
-    and identity_ps ps =
-      match ps with
-      | Br [] -> [ (Var (Var.Db 0), true) ]
-      | Br l ->
-          let incls, _ = canonical_inclusions l in
-          wedge_sub_ps incls
-
-    and wedge_sub_ps l = wedge_sub_ps_bp (List.map sub_ps_to_sub_ps_bp l)
-
-    and wedge_sub_ps_bp l =
-      let lp = (List.last l).l in
-      List.fold_right
-        (fun s sub -> List.append s.sub_ps ((s.r, false) :: sub))
-        l
-        [ (lp, false) ]
-
-    and sub_ps_to_sub_ps_bp sub_ps =
-      match sub_ps with
-      | [] | [ _ ] ->
-          Error.fatal "bipointed substitution need at least two points"
-      | [ (r, _); (l, _) ] -> { sub_ps = []; l; r }
-      | t :: s ->
-          let s = sub_ps_to_sub_ps_bp s in
-          { sub_ps = t :: s.sub_ps; l = s.l; r = s.r }
-
-    let canonical_inclusions l =
-      let incls, _ = canonical_inclusions l in
-      incls
-
-    let tbl_ps_to_ctx : (ps, ctx) Hashtbl.t = Hashtbl.create 7829
-
-    let ps_to_ctx ps =
-      match Hashtbl.find_opt tbl_ps_to_ctx ps with
-      | Some ctx -> ctx
-      | None ->
-          let ctx = (ps_to_ctx_rp ps).ctx in
-          Hashtbl.add tbl_ps_to_ctx ps ctx;
-          ctx
-
-    let suspwedge_subs_ps list_subs list_ps =
-      let incls = canonical_inclusions list_ps in
-      wedge_sub_ps
-        (List.map2
-           (fun s i -> sub_ps_apply_sub (suspend_sub_ps s) (sub_ps_to_sub i))
-           list_subs incls)
-
-    let opsuspwedge_subs_ps list_subs list_ps =
-      let rec swap_bp sub =
-        match sub with
-        | [] | [ _ ] -> Error.fatal "wedge without two basepoints"
-        | [ r; l ] -> [ l; r ]
-        | t :: sub -> t :: swap_bp sub
-      in
-      let incls = canonical_inclusions list_ps in
-      wedge_sub_ps
-        (List.map2
-           (fun s i ->
-             sub_ps_apply_sub (swap_bp (suspend_sub_ps s)) (sub_ps_to_sub i))
-           (List.rev list_subs) (List.rev incls))
-
-    let rec ps_bdry i ps =
-      match ps with
-      | Br [] -> Br []
-      | Br _ when i <= 0 -> Br []
-      | Br l -> Br (List.map (ps_bdry (i - 1)) l)
-
-    let rec ps_src i ps =
-      match (i, ps) with
-      | 0, _ -> [ (Var (Var.Db 0), true) ]
-      | _, Br [] -> [ (Var (Var.Db 0), true) ]
-      | i, Br l -> suspwedge_subs_ps (List.map (ps_src (i - 1)) l) l
-
-    let rec ps_tgt i ps =
-      match (i, ps) with
-      | 0, ps ->
-          let c = ps_to_ctx_rp ps in
-          [ (Var (Var.Db c.rp), true) ]
-      | _, Br [] -> [ (Var (Var.Db 0), true) ]
-      | i, Br l -> suspwedge_subs_ps (List.map (ps_tgt (i - 1)) l) l
-
-    let ps_bdry ps = ps_bdry (dim_ps ps - 1) ps
-    let ps_src ps = ps_src (dim_ps ps - 1) ps
-    let ps_tgt ps = ps_tgt (dim_ps ps - 1) ps
-
-    let rec ps_compose i ps1 ps2 =
-      match (i, ps1, ps2) with
-      | 0, Br l1, Br l2 ->
-          let i1 = identity_ps (Br l1) in
-          let i2 = identity_ps (Br l2) in
-          let ctx_bp = ps_to_ctx_rp ps1 in
-          let i2 = List.map (fun (x, e) -> (tm_inr_wedge x ctx_bp, e)) i2 in
-          (Br (List.append l2 l1), i1, i2)
-      | _, Br [], Br [] ->
-          let s = identity_ps ps1 in
-          (ps1, s, s)
-      | i, Br l1, Br l2 -> (
-          try
-            let list = List.map2 (ps_compose (i - 1)) l1 l2 in
-            let lps = List.map (fun (x, _, _) -> x) list in
-            let li1 = List.map (fun (_, x, _) -> x) list in
-            let li2 = List.map (fun (_, _, x) -> x) list in
-            (Br lps, suspwedge_subs_ps li1 lps, suspwedge_subs_ps li2 lps)
-          with Invalid_argument _ ->
-            Error.fatal
-              "composition of pasting schemes only allowed when \
-               theirboundaries match up")
-
-    let rec pullback_up i ps1 ps2 s1 s2 =
-      match (i, ps1, ps2, s1, s2) with
-      | 0, _, _, s1, s2 ->
-          let rec append s2 =
-            match s2 with
-            | [] -> Error.fatal "substitution to pasting scheme cannot be empty"
-            | [ _ ] -> s1
-            | t :: s2 -> t :: append s2
-          in
-          append s2
-      | _, Br [], Br [], _, _ -> s1
-      | i, Br l1, Br l2, s1, s2 ->
-          let incls1 = canonical_inclusions l1 in
-          let incls2 = canonical_inclusions l2 in
-          let s1 = sub_ps_to_sub s1 in
-          let s2 = sub_ps_to_sub s2 in
-          let ls =
-            List.map4
-              (fun ps1 ps2 i1 i2 ->
-                let s1 = sub_ps_to_sub_ps_bp (sub_ps_apply_sub i1 s1) in
-                let s2 = sub_ps_to_sub_ps_bp (sub_ps_apply_sub i2 s2) in
-                let hom_sub = pullback_up (i - 1) ps1 ps2 s1.sub_ps s2.sub_ps in
-                { sub_ps = hom_sub; l = s1.l; r = s1.r })
-              l1 l2 incls1 incls2
-          in
-          wedge_sub_ps_bp ls
-
-    let rec tm_contains_var t x =
-      match t with
-      | Var v -> v = x
-      | Coh (_, s) -> List.exists (fun (t, _) -> tm_contains_var t x) s
-      | App (t, s) ->
-          List.exists
-            (fun (y, (u, _)) ->
-              tm_contains_var (Tm.develop t) y && tm_contains_var u x)
-            s
-      | Meta_tm _ -> Error.fatal "meta-variables should be resolved"
-
-    let rec ty_contains_var a x =
-      match a with
-      | Obj -> false
-      | Arr (a, t, u) ->
-          tm_contains_var t x || tm_contains_var u x || ty_contains_var a x
-      | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
-
-    let tm_contains_vars t l = List.exists (tm_contains_var t) l
-
-    let rec list_to_sub s ctx =
-      match (s, ctx) with
-      | t :: s, (x, (_, expl)) :: ctx -> (x, (t, expl)) :: list_to_sub s ctx
-      | [], [] -> []
-      | _ -> raise WrongNumberOfArguments
-
-    let list_to_db_level_sub l =
-      let rec aux l =
-        match l with
-        | [] -> ([], 0)
-        | t :: l ->
-            let s, n = aux l in
-            ((Var.Db n, t) :: s, n + 1)
-      in
-      fst (aux l)
-
-    let rec dim_ty = function
-      | Obj -> 0
-      | Arr (a, _, _) -> 1 + dim_ty a
-      | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
-
-    let rec dim_ctx = function
-      | [] -> 0
-      | (_, (t, _)) :: c -> max (dim_ctx c) (dim_ty t)
-
-    let rec ty_to_sub_ps a =
-      match a with
-      | Obj -> []
-      | Arr (a, u, v) -> (v, false) :: (u, false) :: ty_to_sub_ps a
-      | Meta_ty _ ->
+        | _ ->
+            { ctx = (v, (suspend_ty t, expl)) :: c.ctx; max = c.max; rp = c.rp }
+        )
+
+  and suspend_ctx ctx = (suspend_ctx_rp ctx).ctx
+
+  let rec dim_ps = function Br [] -> 0 | Br l -> 1 + max_list_ps l
+
+  and max_list_ps = function
+    | [] -> 0
+    | p :: l -> max (dim_ps p) (max_list_ps l)
+
+  let var_inr_wedge v ctx_bp =
+    match v with
+    | Var.Db j -> if j = 0 then Var.Db ctx_bp.rp else Var.Db (j + ctx_bp.max)
+    | _ -> Error.fatal "expecting a de-bruijn level"
+
+  let ty_inr_wedge ty ctx_bp =
+    ty_do_on_variables ty (fun v -> Var (var_inr_wedge v ctx_bp))
+
+  let tm_inr_wedge tm ctx_bp =
+    tm_do_on_variables tm (fun v -> Var (var_inr_wedge v ctx_bp))
+
+  let rec ps_to_ctx_rp ps =
+    match ps with
+    | Br [] -> { ctx = [ (Var.Db 0, (Obj, true)) ]; rp = 0; max = 0 }
+    | Br l ->
+        let _, ctx = canonical_inclusions l in
+        ctx
+
+  and canonical_inclusions l =
+    match l with
+    | [] -> Error.fatal "empty inclusions"
+    | [ ps ] ->
+        ( [ suspend_sub_ps (identity_ps ps) ],
+          suspend_ctx_rp (ps_to_ctx_rp ps).ctx )
+    | ps :: l ->
+        let id = suspend_sub_ps (identity_ps ps) in
+        let ctx_ps = suspend_ctx_rp (ps_to_ctx_rp ps).ctx in
+        let incls, ctx_base = canonical_inclusions l in
+        let ctx_bp =
+          {
+            ctx = append_onto_ctx ctx_ps ctx_base;
+            rp = ctx_ps.rp + ctx_base.max;
+            max = ctx_ps.max + ctx_base.max;
+          }
+        in
+        let incl = List.map (fun (t, e) -> (tm_inr_wedge t ctx_base, e)) id in
+        (incl :: incls, ctx_bp)
+
+  and append_onto_ctx ctx base =
+    let rec aux = function
+      | [] -> Error.fatal "empty context in wedge"
+      | [ _ ] -> base.ctx
+      | (v, (t, expl)) :: ctx ->
+          let t = ty_inr_wedge t base in
+          let v = var_inr_wedge v base in
+          (v, (t, expl)) :: aux ctx
+    in
+    aux ctx.ctx
+
+  and identity_ps ps =
+    match ps with
+    | Br [] -> [ (Var (Var.Db 0), true) ]
+    | Br l ->
+        let incls, _ = canonical_inclusions l in
+        wedge_sub_ps incls
+
+  and wedge_sub_ps l = wedge_sub_ps_bp (List.map sub_ps_to_sub_ps_bp l)
+
+  and wedge_sub_ps_bp l =
+    let lp = (List.last l).l in
+    List.fold_right
+      (fun s sub -> List.append s.sub_ps ((s.r, false) :: sub))
+      l
+      [ (lp, false) ]
+
+  and sub_ps_to_sub_ps_bp sub_ps =
+    match sub_ps with
+    | [] | [ _ ] ->
+        Error.fatal "bipointed substitution need at least two points"
+    | [ (r, _); (l, _) ] -> { sub_ps = []; l; r }
+    | t :: s ->
+        let s = sub_ps_to_sub_ps_bp s in
+        { sub_ps = t :: s.sub_ps; l = s.l; r = s.r }
+
+  let canonical_inclusions l =
+    let incls, _ = canonical_inclusions l in
+    incls
+
+  let tbl_ps_to_ctx : (ps, (Coh.t, Tm.t) ctx) Hashtbl.t = Hashtbl.create 7829
+
+  let ps_to_ctx ps =
+    match Hashtbl.find_opt tbl_ps_to_ctx ps with
+    | Some ctx -> ctx
+    | None ->
+        let ctx = (ps_to_ctx_rp ps).ctx in
+        Hashtbl.add tbl_ps_to_ctx ps ctx;
+        ctx
+
+  let suspwedge_subs_ps list_subs list_ps =
+    let incls = canonical_inclusions list_ps in
+    wedge_sub_ps
+      (List.map2
+         (fun s i -> sub_ps_apply_sub (suspend_sub_ps s) (sub_ps_to_sub i))
+         list_subs incls)
+
+  let opsuspwedge_subs_ps list_subs list_ps =
+    let rec swap_bp sub =
+      match sub with
+      | [] | [ _ ] -> Error.fatal "wedge without two basepoints"
+      | [ r; l ] -> [ l; r ]
+      | t :: sub -> t :: swap_bp sub
+    in
+    let incls = canonical_inclusions list_ps in
+    wedge_sub_ps
+      (List.map2
+         (fun s i ->
+           sub_ps_apply_sub (swap_bp (suspend_sub_ps s)) (sub_ps_to_sub i))
+         (List.rev list_subs) (List.rev incls))
+
+  let rec ps_bdry i ps =
+    match ps with
+    | Br [] -> Br []
+    | Br _ when i <= 0 -> Br []
+    | Br l -> Br (List.map (ps_bdry (i - 1)) l)
+
+  let rec ps_src i ps =
+    match (i, ps) with
+    | 0, _ -> [ (Var (Var.Db 0), true) ]
+    | _, Br [] -> [ (Var (Var.Db 0), true) ]
+    | i, Br l -> suspwedge_subs_ps (List.map (ps_src (i - 1)) l) l
+
+  let rec ps_tgt i ps =
+    match (i, ps) with
+    | 0, ps ->
+        let c = ps_to_ctx_rp ps in
+        [ (Var (Var.Db c.rp), true) ]
+    | _, Br [] -> [ (Var (Var.Db 0), true) ]
+    | i, Br l -> suspwedge_subs_ps (List.map (ps_tgt (i - 1)) l) l
+
+  let ps_bdry ps = ps_bdry (dim_ps ps - 1) ps
+  let ps_src ps = ps_src (dim_ps ps - 1) ps
+  let ps_tgt ps = ps_tgt (dim_ps ps - 1) ps
+
+  let rec ps_compose i ps1 ps2 =
+    match (i, ps1, ps2) with
+    | 0, Br l1, Br l2 ->
+        let i1 = identity_ps (Br l1) in
+        let i2 = identity_ps (Br l2) in
+        let ctx_bp = ps_to_ctx_rp ps1 in
+        let i2 = List.map (fun (x, e) -> (tm_inr_wedge x ctx_bp, e)) i2 in
+        (Br (List.append l2 l1), i1, i2)
+    | _, Br [], Br [] ->
+        let s = identity_ps ps1 in
+        (ps1, s, s)
+    | i, Br l1, Br l2 -> (
+        try
+          let list = List.map2 (ps_compose (i - 1)) l1 l2 in
+          let lps = List.map (fun (x, _, _) -> x) list in
+          let li1 = List.map (fun (_, x, _) -> x) list in
+          let li2 = List.map (fun (_, _, x) -> x) list in
+          (Br lps, suspwedge_subs_ps li1 lps, suspwedge_subs_ps li2 lps)
+        with Invalid_argument _ ->
           Error.fatal
-            "substitution can only be computed after resolving the type"
-
-    let coh_to_sub_ps t =
-      match t with
-      | Coh (coh, s) ->
-          let _, ty, _ = Coh.forget coh in
-          let sub = sub_ps_to_sub s in
-          (t, true) :: ty_to_sub_ps (ty_apply_sub ty sub)
-      | _ -> Error.fatal "can only convert coh to sub ps"
-
-    let rec identity ctx =
-      match ctx with
-      | [] -> []
-      | (x, (_, e)) :: ctx -> (x, (Var x, e)) :: identity ctx
-
-    let rec disc = function 0 -> Br [] | n -> Br [ disc (n - 1) ]
-    let disc_ctx n = ps_to_ctx (disc n)
-
-    let rec disc_type n =
-      if n = 0 then Obj
-      else
-        Arr
-          ( disc_type (n - 1),
-            Var (Var.Db ((2 * n) - 2)),
-            Var (Var.Db ((2 * n) - 1)) )
-
-    let sphere n =
-      if n = -1 then []
-      else
-        let d = ps_to_ctx (disc n) in
-        (Var.Db ((2 * n) + 1), (disc_type n, true)) :: d
-
-    let sphere_inc n = identity (sphere n)
-    let disc_src n = identity_ps (disc n)
-
-    let disc_tgt n =
-      (Var (Var.Db ((2 * n) + 1)), true)
-      :: (Var (Var.Db ((2 * n) - 1)), true)
-      :: identity_ps (disc (n - 1))
-
-    let rec develop_tm tm =
-      match tm with
-      | Var v -> Var v
-      | Meta_tm i -> Meta_tm i
-      | Coh (coh, s) -> Coh (coh, develop_sub_ps s)
-      | App (tm, s) -> tm_apply_sub (Tm.develop tm) (develop_sub s)
-
-    and develop_sub_ps s = List.map (fun (t, b) -> (develop_tm t, b)) s
-    and develop_sub s = List.map (fun (x, (t, b)) -> (x, (develop_tm t, b))) s
-
-    let rec develop_ty ty =
-      match ty with
-      | Obj -> Obj
-      | Meta_ty i -> Meta_ty i
-      | Arr (a, t, u) -> Arr (develop_ty a, develop_tm t, develop_tm u)
-  end
+            "composition of pasting schemes only allowed when theirboundaries \
+             match up")
+
+  let rec pullback_up i ps1 ps2 s1 s2 =
+    match (i, ps1, ps2, s1, s2) with
+    | 0, _, _, s1, s2 ->
+        let rec append s2 =
+          match s2 with
+          | [] -> Error.fatal "substitution to pasting scheme cannot be empty"
+          | [ _ ] -> s1
+          | t :: s2 -> t :: append s2
+        in
+        append s2
+    | _, Br [], Br [], _, _ -> s1
+    | i, Br l1, Br l2, s1, s2 ->
+        let incls1 = canonical_inclusions l1 in
+        let incls2 = canonical_inclusions l2 in
+        let s1 = sub_ps_to_sub s1 in
+        let s2 = sub_ps_to_sub s2 in
+        let ls =
+          List.map4
+            (fun ps1 ps2 i1 i2 ->
+              let s1 = sub_ps_to_sub_ps_bp (sub_ps_apply_sub i1 s1) in
+              let s2 = sub_ps_to_sub_ps_bp (sub_ps_apply_sub i2 s2) in
+              let hom_sub = pullback_up (i - 1) ps1 ps2 s1.sub_ps s2.sub_ps in
+              { sub_ps = hom_sub; l = s1.l; r = s1.r })
+            l1 l2 incls1 incls2
+        in
+        wedge_sub_ps_bp ls
+
+  let rec tm_contains_var t x =
+    match t with
+    | Var v -> v = x
+    | Coh (_, s) -> List.exists (fun (t, _) -> tm_contains_var t x) s
+    | App (t, s) ->
+        List.exists
+          (fun (y, (u, _)) ->
+            tm_contains_var (Tm.develop t) y && tm_contains_var u x)
+          s
+    | Meta_tm _ -> Error.fatal "meta-variables should be resolved"
+
+  let rec ty_contains_var a x =
+    match a with
+    | Obj -> false
+    | Arr (a, t, u) ->
+        tm_contains_var t x || tm_contains_var u x || ty_contains_var a x
+    | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
+
+  let tm_contains_vars t l = List.exists (tm_contains_var t) l
+
+  let rec list_to_sub s ctx =
+    match (s, ctx) with
+    | t :: s, (x, (_, expl)) :: ctx -> (x, (t, expl)) :: list_to_sub s ctx
+    | [], [] -> []
+    | _ -> raise WrongNumberOfArguments
+
+  let list_to_db_level_sub l =
+    let rec aux l =
+      match l with
+      | [] -> ([], 0)
+      | t :: l ->
+          let s, n = aux l in
+          ((Var.Db n, t) :: s, n + 1)
+    in
+    fst (aux l)
+
+  let rec dim_ty = function
+    | Obj -> 0
+    | Arr (a, _, _) -> 1 + dim_ty a
+    | Meta_ty _ -> Error.fatal "meta-variables should be resolved"
+
+  let rec dim_ctx = function
+    | [] -> 0
+    | (_, (t, _)) :: c -> max (dim_ctx c) (dim_ty t)
+
+  let rec ty_to_sub_ps a =
+    match a with
+    | Obj -> []
+    | Arr (a, u, v) -> (v, false) :: (u, false) :: ty_to_sub_ps a
+    | Meta_ty _ ->
+        Error.fatal "substitution can only be computed after resolving the type"
+
+  let coh_to_sub_ps t =
+    match t with
+    | Coh (coh, s) ->
+        let _, ty, _ = Coh.forget coh in
+        let sub = sub_ps_to_sub s in
+        (t, true) :: ty_to_sub_ps (ty_apply_sub ty sub)
+    | _ -> Error.fatal "can only convert coh to sub ps"
+
+  let rec identity ctx =
+    match ctx with
+    | [] -> []
+    | (x, (_, e)) :: ctx -> (x, (Var x, e)) :: identity ctx
+
+  let rec disc = function 0 -> Br [] | n -> Br [ disc (n - 1) ]
+  let disc_ctx n = ps_to_ctx (disc n)
+
+  let rec disc_type n =
+    if n = 0 then Obj
+    else
+      Arr
+        ( disc_type (n - 1),
+          Var (Var.Db ((2 * n) - 2)),
+          Var (Var.Db ((2 * n) - 1)) )
+
+  let sphere n =
+    if n = -1 then []
+    else
+      let d = ps_to_ctx (disc n) in
+      (Var.Db ((2 * n) + 1), (disc_type n, true)) :: d
+
+  let sphere_inc n = identity (sphere n)
+  let disc_src n = identity_ps (disc n)
+
+  let disc_tgt n =
+    (Var (Var.Db ((2 * n) + 1)), true)
+    :: (Var (Var.Db ((2 * n) - 1)), true)
+    :: identity_ps (disc (n - 1))
+
+  let rec develop_tm tm =
+    match tm with
+    | Var v -> Var v
+    | Meta_tm i -> Meta_tm i
+    | Coh (coh, s) -> Coh (coh, develop_sub_ps s)
+    | App (tm, s) -> tm_apply_sub (Tm.develop tm) (develop_sub s)
+
+  and develop_sub_ps s = List.map (fun (t, b) -> (develop_tm t, b)) s
+  and develop_sub s = List.map (fun (x, (t, b)) -> (x, (develop_tm t, b))) s
+
+  let rec develop_ty ty =
+    match ty with
+    | Obj -> Obj
+    | Meta_ty i -> Meta_ty i
+    | Arr (a, t, u) -> Arr (develop_ty a, develop_tm t, develop_tm u)
 end
diff --git a/lib/internals/unchecked.mli b/lib/internals/unchecked.mli
index 73085bef..c888f001 100644
--- a/lib/internals/unchecked.mli
+++ b/lib/internals/unchecked.mli
@@ -1,25 +1,119 @@
-open Common
-open Unchecked_types
-
-module Unchecked (Coh : sig
-  type t
-end) (Tm : sig
-  type t
-end) : sig
-  open Unchecked_types(Coh)(Tm)
-  open Signatures.Signatures(Coh)(Tm)
-
-  module Make (_ : sig
-    val forget : Coh.t -> ps * Unchecked_types(Coh)(Tm).ty * pp_data
-    val check : ps -> ty -> pp_data -> Coh.t
-  end) (_ : sig
-    val develop : Tm.t -> Unchecked_types(Coh)(Tm).tm
-
-    val apply :
-      (Unchecked_types(Coh)(Tm).ctx -> Unchecked_types(Coh)(Tm).ctx) ->
-      (Unchecked_types(Coh)(Tm).tm -> Unchecked_types(Coh)(Tm).tm) ->
-      (pp_data -> pp_data) ->
-      Tm.t ->
-      Tm.t * Unchecked_types(Coh)(Tm).sub
-  end) : UncheckedS
+module Make (Core : Core.S) : sig
+  open Core
+  open Common
+
+  type sub_ps_bp = {
+    sub_ps : (Coh.t, Tm.t) sub_ps;
+    l : (Coh.t, Tm.t) tm;
+    r : (Coh.t, Tm.t) tm;
+  }
+
+  val dim_ctx : (Coh.t, Tm.t) ctx -> int
+  val dim_ty : (Coh.t, Tm.t) ty -> int
+  val dim_ps : ps -> int
+  val ps_to_ctx : ps -> (Coh.t, Tm.t) ctx
+  val identity_ps : ps -> (Coh.t, Tm.t) sub_ps
+  val tm_apply_sub : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) tm
+  val ty_apply_sub : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) ty
+
+  val sub_apply_sub :
+    (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub
+
+  val sub_ps_apply_sub :
+    (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub_ps
+
+  val ty_apply_sub_ps :
+    (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) ty
+
+  val tm_apply_sub_ps :
+    (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) tm
+
+  val sub_ps_apply_sub_ps :
+    (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps
+
+  val ty_rename :
+    (Coh.t, Tm.t) ty -> (Var.t * (Coh.t, Tm.t) tm) list -> (Coh.t, Tm.t) ty
+
+  val tm_rename :
+    (Coh.t, Tm.t) tm -> (Var.t * (Coh.t, Tm.t) tm) list -> (Coh.t, Tm.t) tm
+
+  val sub_ps_rename :
+    (Coh.t, Tm.t) sub_ps ->
+    (Var.t * (Coh.t, Tm.t) tm) list ->
+    (Coh.t, Tm.t) sub_ps
+
+  val ty_sub_preimage :
+    (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) ty
+
+  val db_levels :
+    (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx * (Var.t * (int * bool)) list * int
+
+  val db_level_sub : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
+  val db_level_sub_inv : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
+
+  val rename_ty :
+    (Coh.t, Tm.t) ty -> (Var.t * (int * bool)) list -> (Coh.t, Tm.t) ty
+
+  val rename_tm :
+    (Coh.t, Tm.t) tm -> (Var.t * (int * bool)) list -> (Coh.t, Tm.t) tm
+
+  val tm_contains_var : (Coh.t, Tm.t) tm -> Var.t -> bool
+  val ty_contains_var : (Coh.t, Tm.t) ty -> Var.t -> bool
+  val tm_contains_vars : (Coh.t, Tm.t) tm -> Var.t list -> bool
+  val sub_ps_to_sub : (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub
+  val sub_to_sub_ps : (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub_ps
+  val suspend_pp_data : pp_data -> pp_data
+  val suspend_ps : ps -> ps
+  val suspend_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty
+  val suspend_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm
+  val suspend_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx
+  val suspend_sub_ps : (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps
+  val suspend_sub : (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub
+  val ps_bdry : ps -> ps
+  val ps_src : ps -> (Coh.t, Tm.t) sub_ps
+  val ps_tgt : ps -> (Coh.t, Tm.t) sub_ps
+
+  val tm_sub_preimage :
+    (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) tm
+
+  val suspwedge_subs_ps :
+    (Coh.t, Tm.t) sub_ps list -> ps list -> (Coh.t, Tm.t) sub_ps
+
+  val opsuspwedge_subs_ps :
+    (Coh.t, Tm.t) sub_ps list -> ps list -> (Coh.t, Tm.t) sub_ps
+
+  val canonical_inclusions : ps list -> (Coh.t, Tm.t) sub_ps list
+  val ty_to_sub_ps : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub_ps
+  val coh_to_sub_ps : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub_ps
+
+  val ps_compose :
+    int -> ps -> ps -> ps * (Coh.t, Tm.t) sub_ps * (Coh.t, Tm.t) sub_ps
+
+  val pullback_up :
+    int ->
+    ps ->
+    ps ->
+    (Coh.t, Tm.t) sub_ps ->
+    (Coh.t, Tm.t) sub_ps ->
+    (Coh.t, Tm.t) sub_ps
+
+  val sub_ps_to_sub_ps_bp : (Coh.t, Tm.t) sub_ps -> sub_ps_bp
+  val wedge_sub_ps_bp : sub_ps_bp list -> (Coh.t, Tm.t) sub_ps
+
+  val list_to_sub :
+    (Coh.t, Tm.t) tm list -> (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
+
+  val list_to_db_level_sub :
+    (Coh.t, Tm.t) tm list -> (Var.t * (Coh.t, Tm.t) tm) list
+
+  val identity : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
+  val disc : int -> ps
+  val disc_ctx : int -> (Coh.t, Tm.t) ctx
+  val disc_type : int -> (Coh.t, Tm.t) ty
+  val sphere : int -> (Coh.t, Tm.t) ctx
+  val sphere_inc : int -> (Coh.t, Tm.t) sub
+  val disc_src : int -> (Coh.t, Tm.t) sub_ps
+  val disc_tgt : int -> (Coh.t, Tm.t) sub_ps
+  val develop_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm
+  val develop_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty
 end
diff --git a/lib/internals/unchecked_types.ml b/lib/internals/unchecked_types.ml
deleted file mode 100644
index a23125a4..00000000
--- a/lib/internals/unchecked_types.ml
+++ /dev/null
@@ -1,47 +0,0 @@
-open Common
-
-module type Unchecked_types_sig = functor
-  (Coh : sig
-     type t
-   end)
-  (Tm : sig
-     type t
-   end)
-  -> sig
-  type ty = Meta_ty of int | Obj | Arr of ty * tm * tm
-
-  and tm =
-    | Var of Var.t
-    | Meta_tm of int
-    | Coh of Coh.t * sub_ps
-    | App of Tm.t * sub
-
-  and sub_ps = (tm * bool) list
-  and sub = (Var.t * (tm * bool)) list
-
-  type ctx = (Var.t * (ty * bool)) list
-  type meta_ctx = (int * ty) list
-  type constr = tm * ty
-end
-
-module Unchecked_types (Coh : sig
-  type t
-end) (Tm : sig
-  type t
-end) =
-struct
-  type ty = Meta_ty of int | Obj | Arr of ty * tm * tm
-
-  and tm =
-    | Var of Var.t
-    | Meta_tm of int
-    | Coh of Coh.t * sub_ps
-    | App of Tm.t * sub
-
-  and sub_ps = (tm * bool) list
-  and sub = (Var.t * (tm * bool)) list
-
-  type ctx = (Var.t * (ty * bool)) list
-  type meta_ctx = (int * ty) list
-  type constr = tm * ty
-end
diff --git a/lib/internals/unchecked_types.mli b/lib/internals/unchecked_types.mli
deleted file mode 100644
index b15008a7..00000000
--- a/lib/internals/unchecked_types.mli
+++ /dev/null
@@ -1,27 +0,0 @@
-open Common
-
-module type Unchecked_types_sig = functor
-  (Coh : sig
-     type t
-   end)
-  (Tm : sig
-     type t
-   end)
-  -> sig
-  type ty = Meta_ty of int | Obj | Arr of ty * tm * tm
-
-  and tm =
-    | Var of Var.t
-    | Meta_tm of int
-    | Coh of Coh.t * sub_ps
-    | App of Tm.t * sub
-
-  and sub_ps = (tm * bool) list
-  and sub = (Var.t * (tm * bool)) list
-
-  type ctx = (Var.t * (ty * bool)) list
-  type meta_ctx = (int * ty) list
-  type constr = tm * ty
-end
-
-module Unchecked_types : Unchecked_types_sig
diff --git a/lib/lib/common.ml b/lib/lib/common.ml
index 4e4448fc..f9920dca 100644
--- a/lib/lib/common.ml
+++ b/lib/lib/common.ml
@@ -47,6 +47,24 @@ module Var = struct
     fresh
 end
 
+type ('a, 'b) ty =
+  | Meta_ty of int
+  | Obj
+  | Arr of ('a, 'b) ty * ('a, 'b) tm * ('a, 'b) tm
+
+and ('a, 'b) tm =
+  | Var of Var.t
+  | Meta_tm of int
+  | Coh of 'a * ('a, 'b) sub_ps
+  | App of 'b * ('a, 'b) sub
+
+and ('a, 'b) sub_ps = (('a, 'b) tm * bool) list
+and ('a, 'b) sub = (Var.t * (('a, 'b) tm * bool)) list
+
+type ('a, 'b) ctx = (Var.t * (('a, 'b) ty * bool)) list
+type ('a, 'b) meta_ctx = (int * ('a, 'b) ty) list
+type ('a, 'b) constr = ('a, 'b) tm * ('a, 'b) ty
+
 (* For application *)
 type pp_data = string * int * (Var.t * int) list list
 
diff --git a/lib/lib/common.mli b/lib/lib/common.mli
index 8fea4929..16f55de8 100644
--- a/lib/lib/common.mli
+++ b/lib/lib/common.mli
@@ -21,6 +21,23 @@ module Var : sig
   val fresh : unit -> t
 end
 
+type ('a, 'b) ty =
+  | Meta_ty of int
+  | Obj
+  | Arr of ('a, 'b) ty * ('a, 'b) tm * ('a, 'b) tm
+
+and ('a, 'b) tm =
+  | Var of Var.t
+  | Meta_tm of int
+  | Coh of 'a * ('a, 'b) sub_ps
+  | App of 'b * ('a, 'b) sub
+
+and ('a, 'b) sub_ps = (('a, 'b) tm * bool) list
+and ('a, 'b) sub = (Var.t * (('a, 'b) tm * bool)) list
+
+type ('a, 'b) ctx = (Var.t * (('a, 'b) ty * bool)) list
+type ('a, 'b) meta_ctx = (int * ('a, 'b) ty) list
+type ('a, 'b) constr = ('a, 'b) tm * ('a, 'b) ty
 type pp_data = string * int * (Var.t * int) list list
 
 val take : int -> 'a list -> 'a list
diff --git a/lib/lib/meta.ml b/lib/lib/meta.ml
index 8ed27c01..140b6c38 100644
--- a/lib/lib/meta.ml
+++ b/lib/lib/meta.ml
@@ -1,4 +1,4 @@
-open Kernel
+open Common
 
 let meta_namer_ty = ref 0
 let meta_namer_tm = ref 0

From e4977941931a3fb080466be9694fa51b9cb880a8 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 24 Oct 2025 10:23:31 +0200
Subject: [PATCH 21/30] [internals] add support for multiple theories

---
 lib/elaboration/elaborate.ml              |  698 ++++-----
 lib/elaboration/elaborate.mli             |   13 +-
 lib/elaboration/translate_raw.ml          |  344 ++---
 lib/elaboration/translate_raw.mli         |   13 +-
 lib/internals/kernel.ml                   | 1620 +++++++++++----------
 lib/internals/kernel.mli                  |  189 +--
 lib/internals/theory.ml                   |   13 +
 lib/internals/theory.mli                  |    8 +
 lib/lib/command.ml                        |  336 +++--
 lib/lib/command.mli                       |    4 +-
 lib/lib/common.ml                         |   14 +
 lib/lib/common.mli                        |   13 +
 lib/lib/environment.ml                    |   83 --
 lib/lib/environment.mli                   |   16 -
 lib/lib/environments.ml                   |  169 +++
 lib/lib/environments.mli                  |   42 +
 lib/lib/meta.mli                          |    6 +-
 lib/lib/raw.ml                            |  246 ++--
 lib/lib/raw.mli                           |   15 +-
 lib/meta_operations/builtin.ml            |  183 +--
 lib/meta_operations/builtin.mli           |   29 +-
 lib/meta_operations/comp.ml               |   42 +
 lib/meta_operations/comp.mli              |   14 +
 lib/meta_operations/cones.ml              |  701 ++++-----
 lib/meta_operations/cones.mli             |    6 +-
 lib/meta_operations/construct.ml          |  476 +++---
 lib/meta_operations/construct.mli         |   79 +-
 lib/meta_operations/cubical_composite.ml  |  820 ++++++-----
 lib/meta_operations/cubical_composite.mli |    4 +-
 lib/meta_operations/cylinders.ml          | 1247 ++++++++--------
 lib/meta_operations/cylinders.mli         |    8 +-
 lib/meta_operations/eh.ml                 | 1118 +++++++-------
 lib/meta_operations/eh.mli                |    8 +-
 lib/meta_operations/functorialisation.ml  |  645 ++++----
 lib/meta_operations/functorialisation.mli |   51 +-
 lib/meta_operations/inverse.ml            |  502 +++----
 lib/meta_operations/inverse.mli           |   12 +-
 lib/meta_operations/opposite.ml           |  188 +--
 lib/meta_operations/opposite.mli          |   20 +-
 lib/meta_operations/padding.ml            |  910 ++++++------
 lib/meta_operations/padding.mli           |  233 +--
 lib/meta_operations/ps_reduction.ml       |   62 +-
 lib/meta_operations/ps_reduction.mli      |   11 +-
 lib/meta_operations/suspension.ml         |   42 +-
 lib/meta_operations/suspension.mli        |   21 +-
 lib/meta_operations/telescope.ml          |  344 ++---
 lib/meta_operations/telescope.mli         |   10 +-
 lib/prover.ml                             |    5 +-
 rocq_plugin/src/export.ml                 |   73 +-
 49 files changed, 6079 insertions(+), 5627 deletions(-)
 create mode 100644 lib/internals/theory.ml
 create mode 100644 lib/internals/theory.mli
 delete mode 100644 lib/lib/environment.ml
 delete mode 100644 lib/lib/environment.mli
 create mode 100644 lib/lib/environments.ml
 create mode 100644 lib/lib/environments.mli
 create mode 100644 lib/meta_operations/comp.ml
 create mode 100644 lib/meta_operations/comp.mli

diff --git a/lib/elaboration/elaborate.ml b/lib/elaboration/elaborate.ml
index 9f7d8992..63de8744 100644
--- a/lib/elaboration/elaborate.ml
+++ b/lib/elaboration/elaborate.ml
@@ -1,354 +1,370 @@
 open Std
 open Common
-open Kernel
 
 exception NotUnifiable of string * string
 
 module Queue = Base.Queue
 
-module Constraints = struct
-  type t = { ty : (ty * ty) Queue.t; tm : (tm * tm) Queue.t }
-
-  let create () = { ty = Queue.create (); tm = Queue.create () }
-
-  let _to_string c =
-    let print_ty =
-      Queue.fold c.ty ~init:"" ~f:(fun s (ty1, ty2) ->
-          Printf.sprintf "%s (%s = %s)" s
-            (Printing.ty_to_string ty1)
-            (Printing.ty_to_string ty2))
-    in
-    let print_tm =
-      Queue.fold c.tm ~init:"" ~f:(fun s (tm1, tm2) ->
-          Printf.sprintf "%s (%s = %s)" s
-            (Printing.tm_to_string tm1)
-            (Printing.tm_to_string tm2))
-    in
-    Printf.sprintf "[%s] [%s]" print_ty print_tm
-
-  let rec unify_ty cst ty1 ty2 =
-    match (ty1, ty2) with
-    | Obj, Obj -> ()
-    | Arr (a1, u1, v1), Arr (a2, u2, v2) ->
-        unify_ty cst a1 a2;
-        unify_tm cst u1 u2;
-        unify_tm cst v1 v2
-    | Meta_ty _, _ | _, Meta_ty _ -> Queue.enqueue cst.ty (ty1, ty2)
-    | Arr (_, _, _), Obj | Obj, Arr (_, _, _) ->
-        raise
-          (NotUnifiable (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
-
-  and unify_tm cst tm1 tm2 =
-    match (tm1, tm2) with
-    | Meta_tm _, Meta_tm _ when tm1 = tm2 -> ()
-    | Meta_tm _, _ | _, Meta_tm _ -> Queue.enqueue cst.tm (tm1, tm2)
-    | Var v1, Var v2 when v1 = v2 -> ()
-    | Coh (coh1, s1), Coh (coh2, s2) -> (
-        try
-          Coh.check_equal coh1 coh2;
+module Make (Environment : Environments.S) = struct
+  module Translate_raw = Translate_raw.Make (Environment)
+  module Raw = Raw.Make (Environment)
+  open Environment
+
+  module Constraints = struct
+    type t = { ty : (ty * ty) Queue.t; tm : (tm * tm) Queue.t }
+
+    let create () = { ty = Queue.create (); tm = Queue.create () }
+
+    let _to_string c =
+      let print_ty =
+        Queue.fold c.ty ~init:"" ~f:(fun s (ty1, ty2) ->
+            Printf.sprintf "%s (%s = %s)" s
+              (Printing.ty_to_string ty1)
+              (Printing.ty_to_string ty2))
+      in
+      let print_tm =
+        Queue.fold c.tm ~init:"" ~f:(fun s (tm1, tm2) ->
+            Printf.sprintf "%s (%s = %s)" s
+              (Printing.tm_to_string tm1)
+              (Printing.tm_to_string tm2))
+      in
+      Printf.sprintf "[%s] [%s]" print_ty print_tm
+
+    let rec unify_ty cst ty1 ty2 =
+      match (ty1, ty2) with
+      | Obj, Obj -> ()
+      | Arr (a1, u1, v1), Arr (a2, u2, v2) ->
+          unify_ty cst a1 a2;
+          unify_tm cst u1 u2;
+          unify_tm cst v1 v2
+      | Meta_ty _, _ | _, Meta_ty _ -> Queue.enqueue cst.ty (ty1, ty2)
+      | Arr (_, _, _), Obj | Obj, Arr (_, _, _) ->
+          raise
+            (NotUnifiable (Printing.ty_to_string ty1, Printing.ty_to_string ty2))
+
+    and unify_tm cst tm1 tm2 =
+      match (tm1, tm2) with
+      | Meta_tm _, Meta_tm _ when tm1 = tm2 -> ()
+      | Meta_tm _, _ | _, Meta_tm _ -> Queue.enqueue cst.tm (tm1, tm2)
+      | Var v1, Var v2 when v1 = v2 -> ()
+      | Coh (coh1, s1), Coh (coh2, s2) -> (
+          try
+            Coh.check_equal coh1 coh2;
+            unify_sub_ps cst s1 s2
+          with Invalid_argument _ ->
+            raise (NotUnifiable (Coh.to_string coh1, Coh.to_string coh2)))
+      | App (t1, s1), App (t2, s2) when t1 == t2 -> unify_sub cst s1 s2
+      | App (t, s), ((App _ | Coh _ | Var _) as tm2)
+      | ((Coh _ | Var _) as tm2), App (t, s) ->
+          unify_tm cst (Unchecked.tm_apply_sub (Tm.develop t) s) tm2
+      | Var _, Coh _ | Coh _, Var _ | Var _, Var _ ->
+          raise
+            (NotUnifiable (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
+
+    and unify_sub cst s1 s2 =
+      match (s1, s2) with
+      | [], [] -> ()
+      | (_, (t1, _)) :: s1, (_, (t2, _)) :: s2 ->
+          unify_tm cst t1 t2;
+          unify_sub cst s1 s2
+      | [], _ :: _ | _ :: _, [] ->
+          raise
+            (NotUnifiable (Printing.sub_to_string s1, Printing.sub_to_string s2))
+
+    and unify_sub_ps cst s1 s2 =
+      match (s1, s2) with
+      | [], [] -> ()
+      | (t1, _) :: s1, (t2, _) :: s2 ->
+          unify_tm cst t1 t2;
           unify_sub_ps cst s1 s2
-        with Invalid_argument _ ->
-          raise (NotUnifiable (Coh.to_string coh1, Coh.to_string coh2)))
-    | App (t1, s1), App (t2, s2) when t1 == t2 -> unify_sub cst s1 s2
-    | App (t, s), ((App _ | Coh _ | Var _) as tm2)
-    | ((Coh _ | Var _) as tm2), App (t, s) ->
-        unify_tm cst (Unchecked.tm_apply_sub (Tm.develop t) s) tm2
-    | Var _, Coh _ | Coh _, Var _ | Var _, Var _ ->
-        raise
-          (NotUnifiable (Printing.tm_to_string tm1, Printing.tm_to_string tm2))
-
-  and unify_sub cst s1 s2 =
-    match (s1, s2) with
-    | [], [] -> ()
-    | (_, (t1, _)) :: s1, (_, (t2, _)) :: s2 ->
-        unify_tm cst t1 t2;
-        unify_sub cst s1 s2
-    | [], _ :: _ | _ :: _, [] ->
-        raise
-          (NotUnifiable (Printing.sub_to_string s1, Printing.sub_to_string s2))
-
-  and unify_sub_ps cst s1 s2 =
-    match (s1, s2) with
-    | [], [] -> ()
-    | (t1, _) :: s1, (t2, _) :: s2 ->
-        unify_tm cst t1 t2;
-        unify_sub_ps cst s1 s2
-    | [], _ :: _ | _ :: _, [] ->
-        raise
-          (NotUnifiable
-             (Printing.sub_ps_to_string s1, Printing.sub_ps_to_string s2))
-
-  type mgu = { uty : (int * ty) list; utm : (int * tm) list }
-
-  let combine_mgu m1 m2 =
-    { uty = List.append m1.uty m2.uty; utm = List.append m1.utm m2.utm }
-
-  let rec ty_replace_meta_ty (i, ty') ty =
-    match ty with
-    | Meta_ty j when i = j -> ty'
-    | Meta_ty _ -> ty
-    | Obj -> Obj
-    | Arr (a, u, v) -> Arr (ty_replace_meta_ty (i, ty') a, u, v)
-
-  let rec tm_replace_meta_tm (i, tm') tm =
-    match tm with
-    | Meta_tm j when i = j -> tm'
-    | Meta_tm _ -> tm
-    | Var v -> Var v
-    | Coh (c, s) ->
-        Coh
-          ( c,
-            List.map (fun (t, expl) -> (tm_replace_meta_tm (i, tm') t, expl)) s
-          )
-    | App (t, s) ->
-        App
-          ( t,
-            List.map
-              (fun (x, (t, e)) -> (x, (tm_replace_meta_tm (i, tm') t, e)))
-              s )
-
-  let rec ty_replace_meta_tm (i, tm') ty =
-    match ty with
-    | Meta_ty _ -> ty
-    | Obj -> Obj
-    | Arr (a, u, v) ->
-        Arr
-          ( ty_replace_meta_tm (i, tm') a,
-            tm_replace_meta_tm (i, tm') u,
-            tm_replace_meta_tm (i, tm') v )
-
-  let queue_map_both f = Queue.map ~f:(fun (x, y) -> (f x, f y))
-
-  let cst_replace_ty (i, ty) c =
-    { ty = queue_map_both (ty_replace_meta_ty (i, ty)) c.ty; tm = c.tm }
-
-  let cst_replace_tm (i, tm) c =
-    let ty_replace = ty_replace_meta_tm (i, tm) in
-    let tm_replace = tm_replace_meta_tm (i, tm) in
-    { ty = queue_map_both ty_replace c.ty; tm = queue_map_both tm_replace c.tm }
-
-  let mgu_replace_ty (i, ty) l =
-    { uty = List.map_right (ty_replace_meta_ty (i, ty)) l.uty; utm = l.utm }
-
-  let mgu_replace_tm (i, tm) l =
-    let ty_replace = ty_replace_meta_tm (i, tm) in
-    let tm_replace = tm_replace_meta_tm (i, tm) in
-    {
-      uty = List.map_right ty_replace l.uty;
-      utm = List.map_right tm_replace l.utm;
-    }
-
-  let substitute_ty l ty =
-    let ty =
-      List.fold_left (fun ty (i, tm) -> ty_replace_meta_tm (i, tm) ty) ty l.utm
-    in
-    List.fold_left (fun ty (i, ty') -> ty_replace_meta_ty (i, ty') ty) ty l.uty
-
-  let substitute_tm l tm =
-    List.fold_left (fun tm (i, tm') -> tm_replace_meta_tm (i, tm') tm) tm l.utm
-
-  (* Martelli-Montanari algorithm *)
-  let resolve_one_step c knowns =
-    match Queue.dequeue c.ty with
-    | Some (ty1, ty2) -> (
-        match (ty1, ty2) with
-        | Meta_ty i, Meta_ty j when i = j -> (c, knowns)
-        | Meta_ty i, ty | ty, Meta_ty i ->
-            let c = cst_replace_ty (i, ty) c in
-            let knowns = mgu_replace_ty (i, ty) knowns in
-            (c, { uty = (i, ty) :: knowns.uty; utm = knowns.utm })
-        | ty1, ty2 ->
-            unify_ty c ty1 ty2;
-            (c, knowns))
-    | None -> (
-        match Queue.dequeue c.tm with
-        | Some (tm1, tm2) -> (
-            match (tm1, tm2) with
-            | Meta_tm i, Meta_tm j when i = j -> (c, knowns)
-            | Meta_tm i, tm | tm, Meta_tm i ->
-                let c = cst_replace_tm (i, tm) c in
-                let knowns = mgu_replace_tm (i, tm) knowns in
-                (c, { uty = knowns.uty; utm = (i, tm) :: knowns.utm })
-            | tm1, tm2 ->
-                unify_tm c tm1 tm2;
-                (c, knowns))
-        | None -> Error.fatal "resolving empty constraints")
-
-  let resolve c =
-    let rec aux c knowns =
-      if Queue.is_empty c.tm && Queue.is_empty c.ty then knowns
-      else
-        let c, knowns = resolve_one_step c knowns in
-        aux c knowns
-    in
-    aux c { uty = []; utm = [] }
-end
-
-module Constraints_typing = struct
-  let rec tm ctx meta_ctx t cst =
-    Io.info ~v:5
-      (lazy
-        (Printf.sprintf "constraint typing term %s in ctx %s, meta_ctx %s"
-           (Printing.tm_to_string t)
-           (Printing.ctx_to_string ctx)
-           (Printing.meta_ctx_to_string meta_ctx)));
-    match t with
-    | Var v -> (
-        try (t, fst (List.assoc v ctx))
-        with Not_found ->
-          Error.fatal
-            (Printf.sprintf "variable %s not found in context" (Var.to_string v))
-        )
-    | Meta_tm i -> (t, List.assoc i meta_ctx)
-    | Coh (c, s) ->
-        let ps, ty, _ = Coh.forget c in
-        let tgt = Unchecked.ps_to_ctx ps in
-        let s1 = Unchecked.sub_ps_to_sub s in
-        let s1 = sub ctx meta_ctx s1 tgt cst in
-        ( Coh (c, List.map (fun (_, (t, expl)) -> (t, expl)) s1),
-          Unchecked.ty_apply_sub ty s1 )
-    | App (t, s) ->
-        let tgt = Tm.ctx t in
-        let ty = Ty.forget (Tm.typ t) in
-        let s = sub ctx meta_ctx s tgt cst in
-        (App (t, s), Unchecked.ty_apply_sub ty s)
-
-  and sub src meta_ctx s tgt cst =
-    Io.info ~v:5
-      (lazy
-        (Printf.sprintf
-           "constraint typing substitution %s in ctx %s, target %s, meta_ctx %s"
-           (Printing.sub_to_string_debug s)
-           (Printing.ctx_to_string src)
-           (Printing.ctx_to_string tgt)
-           (Printing.meta_ctx_to_string meta_ctx)));
-    match (s, tgt) with
-    | [], [] -> []
-    | (x, (u, e)) :: s, (_, (t, _)) :: c ->
-        let u, ty = tm src meta_ctx u cst in
-        let s = sub src meta_ctx s c cst in
-        Constraints.unify_ty cst ty (Unchecked.ty_apply_sub t s);
-        (x, (u, e)) :: s
-    | [], _ :: _ | _ :: _, [] -> Error.fatal "wrong number of arguments"
-
-  and ty ctx meta_ctx t cst =
-    Io.info ~v:5
+      | [], _ :: _ | _ :: _, [] ->
+          raise
+            (NotUnifiable
+               (Printing.sub_ps_to_string s1, Printing.sub_ps_to_string s2))
+
+    type mgu = { uty : (int * ty) list; utm : (int * tm) list }
+
+    let combine_mgu m1 m2 =
+      { uty = List.append m1.uty m2.uty; utm = List.append m1.utm m2.utm }
+
+    let rec ty_replace_meta_ty (i, ty') ty =
+      match ty with
+      | Meta_ty j when i = j -> ty'
+      | Meta_ty _ -> ty
+      | Obj -> Obj
+      | Arr (a, u, v) -> Arr (ty_replace_meta_ty (i, ty') a, u, v)
+
+    let rec tm_replace_meta_tm (i, tm') tm =
+      match tm with
+      | Meta_tm j when i = j -> tm'
+      | Meta_tm _ -> tm
+      | Var v -> Var v
+      | Coh (c, s) ->
+          Coh
+            ( c,
+              List.map
+                (fun (t, expl) -> (tm_replace_meta_tm (i, tm') t, expl))
+                s )
+      | App (t, s) ->
+          App
+            ( t,
+              List.map
+                (fun (x, (t, e)) -> (x, (tm_replace_meta_tm (i, tm') t, e)))
+                s )
+
+    let rec ty_replace_meta_tm (i, tm') ty =
+      match ty with
+      | Meta_ty _ -> ty
+      | Obj -> Obj
+      | Arr (a, u, v) ->
+          Arr
+            ( ty_replace_meta_tm (i, tm') a,
+              tm_replace_meta_tm (i, tm') u,
+              tm_replace_meta_tm (i, tm') v )
+
+    let queue_map_both f = Queue.map ~f:(fun (x, y) -> (f x, f y))
+
+    let cst_replace_ty (i, ty) c =
+      { ty = queue_map_both (ty_replace_meta_ty (i, ty)) c.ty; tm = c.tm }
+
+    let cst_replace_tm (i, tm) c =
+      let ty_replace = ty_replace_meta_tm (i, tm) in
+      let tm_replace = tm_replace_meta_tm (i, tm) in
+      {
+        ty = queue_map_both ty_replace c.ty;
+        tm = queue_map_both tm_replace c.tm;
+      }
+
+    let mgu_replace_ty (i, ty) l =
+      { uty = List.map_right (ty_replace_meta_ty (i, ty)) l.uty; utm = l.utm }
+
+    let mgu_replace_tm (i, tm) l =
+      let ty_replace = ty_replace_meta_tm (i, tm) in
+      let tm_replace = tm_replace_meta_tm (i, tm) in
+      {
+        uty = List.map_right ty_replace l.uty;
+        utm = List.map_right tm_replace l.utm;
+      }
+
+    let substitute_ty l ty =
+      let ty =
+        List.fold_left
+          (fun ty (i, tm) -> ty_replace_meta_tm (i, tm) ty)
+          ty l.utm
+      in
+      List.fold_left
+        (fun ty (i, ty') -> ty_replace_meta_ty (i, ty') ty)
+        ty l.uty
+
+    let substitute_tm l tm =
+      List.fold_left
+        (fun tm (i, tm') -> tm_replace_meta_tm (i, tm') tm)
+        tm l.utm
+
+    (* Martelli-Montanari algorithm *)
+    let resolve_one_step c knowns =
+      match Queue.dequeue c.ty with
+      | Some (ty1, ty2) -> (
+          match (ty1, ty2) with
+          | Meta_ty i, Meta_ty j when i = j -> (c, knowns)
+          | Meta_ty i, ty | ty, Meta_ty i ->
+              let c = cst_replace_ty (i, ty) c in
+              let knowns = mgu_replace_ty (i, ty) knowns in
+              (c, { uty = (i, ty) :: knowns.uty; utm = knowns.utm })
+          | ty1, ty2 ->
+              unify_ty c ty1 ty2;
+              (c, knowns))
+      | None -> (
+          match Queue.dequeue c.tm with
+          | Some (tm1, tm2) -> (
+              match (tm1, tm2) with
+              | Meta_tm i, Meta_tm j when i = j -> (c, knowns)
+              | Meta_tm i, tm | tm, Meta_tm i ->
+                  let c = cst_replace_tm (i, tm) c in
+                  let knowns = mgu_replace_tm (i, tm) knowns in
+                  (c, { uty = knowns.uty; utm = (i, tm) :: knowns.utm })
+              | tm1, tm2 ->
+                  unify_tm c tm1 tm2;
+                  (c, knowns))
+          | None -> Error.fatal "resolving empty constraints")
+
+    let resolve c =
+      let rec aux c knowns =
+        if Queue.is_empty c.tm && Queue.is_empty c.ty then knowns
+        else
+          let c, knowns = resolve_one_step c knowns in
+          aux c knowns
+      in
+      aux c { uty = []; utm = [] }
+  end
+
+  module Constraints_typing = struct
+    let rec tm ctx meta_ctx t cst =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "constraint typing term %s in ctx %s, meta_ctx %s"
+             (Printing.tm_to_string t)
+             (Printing.ctx_to_string ctx)
+             (Printing.meta_ctx_to_string meta_ctx)));
+      match t with
+      | Var v -> (
+          try (t, fst (List.assoc v ctx))
+          with Not_found ->
+            Error.fatal
+              (Printf.sprintf "variable %s not found in context"
+                 (Var.to_string v)))
+      | Meta_tm i -> (t, List.assoc i meta_ctx)
+      | Coh (c, s) ->
+          let ps, ty, _ = Coh.forget c in
+          let tgt = Unchecked.ps_to_ctx ps in
+          let s1 = Unchecked.sub_ps_to_sub s in
+          let s1 = sub ctx meta_ctx s1 tgt cst in
+          ( Coh (c, List.map (fun (_, (t, expl)) -> (t, expl)) s1),
+            Unchecked.ty_apply_sub ty s1 )
+      | App (t, s) ->
+          let tgt = Tm.ctx t in
+          let ty = Ty.forget (Tm.typ t) in
+          let s = sub ctx meta_ctx s tgt cst in
+          (App (t, s), Unchecked.ty_apply_sub ty s)
+
+    and sub src meta_ctx s tgt cst =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf
+             "constraint typing substitution %s in ctx %s, target %s, meta_ctx \
+              %s"
+             (Printing.sub_to_string_debug s)
+             (Printing.ctx_to_string src)
+             (Printing.ctx_to_string tgt)
+             (Printing.meta_ctx_to_string meta_ctx)));
+      match (s, tgt) with
+      | [], [] -> []
+      | (x, (u, e)) :: s, (_, (t, _)) :: c ->
+          let u, ty = tm src meta_ctx u cst in
+          let s = sub src meta_ctx s c cst in
+          Constraints.unify_ty cst ty (Unchecked.ty_apply_sub t s);
+          (x, (u, e)) :: s
+      | [], _ :: _ | _ :: _, [] -> Error.fatal "wrong number of arguments"
+
+    and ty ctx meta_ctx t cst =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "constraint typing type %s in ctx %s, meta_ctx %s"
+             (Printing.ty_to_string t)
+             (Printing.ctx_to_string ctx)
+             (Printing.meta_ctx_to_string meta_ctx)));
+      match t with
+      | Obj -> Obj
+      | Arr (a, u, v) ->
+          let u, tu = tm ctx meta_ctx u cst in
+          let v, tv = tm ctx meta_ctx v cst in
+          let a = ty ctx meta_ctx a cst in
+          Constraints.unify_ty cst a tu;
+          Constraints.unify_ty cst a tv;
+          Arr (a, u, v)
+      | Meta_ty _ -> t
+
+    let tm ctx meta_ctx t cst = fst (tm ctx meta_ctx t cst)
+
+    let rec ctx c meta_ctx =
+      match c with
+      | [] -> ([], { Constraints.uty = []; utm = [] })
+      | (x, (t, expl)) :: c ->
+          let c, known_mgu = ctx c meta_ctx in
+          let t = Constraints.substitute_ty known_mgu t in
+          let cstt = Constraints.create () in
+          let t = ty c meta_ctx t cstt in
+          let new_mgu = Constraints.resolve cstt in
+          let t = Constraints.substitute_ty new_mgu t in
+          ((x, (t, expl)) :: c, Constraints.combine_mgu known_mgu new_mgu)
+  end
+
+  let preprocess_ty ctx ty =
+    let ty = Raw.remove_let_ty ty in
+    if !Settings.implicit_suspension then Raw.infer_susp_ty ctx ty else ty
+
+  let preprocess_tm ctx tm =
+    let tm = Raw.remove_let_tm tm in
+    if !Settings.implicit_suspension then Raw.infer_susp_tm ctx tm else tm
+
+  let rec preprocess_ctx = function
+    | [] -> []
+    | (v, t) :: c ->
+        let c = preprocess_ctx c in
+        (v, preprocess_ty c t) :: c
+
+  let solve_cst ~elab_fn ~print_fn ~kind x =
+    let name = kind ^ ": " ^ print_fn x in
+    Io.info ~v:2 (lazy (Printf.sprintf "inferring constraints for %s" name));
+    try
+      let x = elab_fn x in
+      Io.info ~v:3
+        (lazy (Printf.sprintf "%s elaborated to %s" kind (print_fn x)));
+      x
+    with NotUnifiable (a, b) ->
+      Error.unsatisfiable_constraints name
+        (Printf.sprintf "could not unify %s and %s" a b)
+
+  let ctx c =
+    let c, meta_ctx = Translate_raw.ctx c in
+    let elab_fn c = fst (Constraints_typing.ctx c meta_ctx) in
+    solve_cst ~elab_fn ~print_fn:Printing.ctx_to_string ~kind:"context" c
+
+  let elab_ty ctx meta_ctx ty =
+    let cst = Constraints.create () in
+    let x = Constraints_typing.ty ctx meta_ctx ty cst in
+    Io.info ~v:4
       (lazy
-        (Printf.sprintf "constraint typing type %s in ctx %s, meta_ctx %s"
-           (Printing.ty_to_string t)
-           (Printing.ctx_to_string ctx)
-           (Printing.meta_ctx_to_string meta_ctx)));
-    match t with
-    | Obj -> Obj
-    | Arr (a, u, v) ->
-        let u, tu = tm ctx meta_ctx u cst in
-        let v, tv = tm ctx meta_ctx v cst in
-        let a = ty ctx meta_ctx a cst in
-        Constraints.unify_ty cst a tu;
-        Constraints.unify_ty cst a tv;
-        Arr (a, u, v)
-    | Meta_ty _ -> t
-
-  let tm ctx meta_ctx t cst = fst (tm ctx meta_ctx t cst)
-
-  let rec ctx c meta_ctx =
-    match c with
-    | [] -> ([], { Constraints.uty = []; utm = [] })
-    | (x, (t, expl)) :: c ->
-        let c, known_mgu = ctx c meta_ctx in
-        let t = Constraints.substitute_ty known_mgu t in
-        let cstt = Constraints.create () in
-        let t = ty c meta_ctx t cstt in
-        let new_mgu = Constraints.resolve cstt in
-        let t = Constraints.substitute_ty new_mgu t in
-        ((x, (t, expl)) :: c, Constraints.combine_mgu known_mgu new_mgu)
-end
-
-let preprocess_ty ctx ty =
-  let ty = Raw.remove_let_ty ty in
-  if !Settings.implicit_suspension then Raw.infer_susp_ty ctx ty else ty
+        (Printf.sprintf "inferred constraints:%s" (Constraints._to_string cst)));
+    let x = Constraints.substitute_ty (Constraints.resolve cst) x in
+    x
 
-let preprocess_tm ctx tm =
-  let tm = Raw.remove_let_tm tm in
-  if !Settings.implicit_suspension then Raw.infer_susp_tm ctx tm else tm
+  let elab_tm ctx meta_ctx tm =
+    let cst = Constraints.create () in
+    let x = Constraints_typing.tm ctx meta_ctx tm cst in
+    Io.info ~v:4
+      (lazy
+        (Printf.sprintf "inferred constraints:%s" (Constraints._to_string cst)));
+    let x = Constraints.substitute_tm (Constraints.resolve cst) x in
+    x
 
-let rec preprocess_ctx = function
-  | [] -> []
-  | (v, t) :: c ->
+  let ty c ty =
+    try
       let c = preprocess_ctx c in
-      (v, preprocess_ty c t) :: c
-
-let solve_cst ~elab_fn ~print_fn ~kind x =
-  let name = kind ^ ": " ^ print_fn x in
-  Io.info ~v:2 (lazy (Printf.sprintf "inferring constraints for %s" name));
-  try
-    let x = elab_fn x in
-    Io.info ~v:3 (lazy (Printf.sprintf "%s elaborated to %s" kind (print_fn x)));
-    x
-  with NotUnifiable (a, b) ->
-    Error.unsatisfiable_constraints name
-      (Printf.sprintf "could not unify %s and %s" a b)
-
-let ctx c =
-  let c, meta_ctx = Translate_raw.ctx c in
-  let elab_fn c = fst (Constraints_typing.ctx c meta_ctx) in
-  solve_cst ~elab_fn ~print_fn:Printing.ctx_to_string ~kind:"context" c
-
-let elab_ty ctx meta_ctx ty =
-  let cst = Constraints.create () in
-  let x = Constraints_typing.ty ctx meta_ctx ty cst in
-  Io.info ~v:4
-    (lazy
-      (Printf.sprintf "inferred constraints:%s" (Constraints._to_string cst)));
-  let x = Constraints.substitute_ty (Constraints.resolve cst) x in
-  x
-
-let elab_tm ctx meta_ctx tm =
-  let cst = Constraints.create () in
-  let x = Constraints_typing.tm ctx meta_ctx tm cst in
-  Io.info ~v:4
-    (lazy
-      (Printf.sprintf "inferred constraints:%s" (Constraints._to_string cst)));
-  let x = Constraints.substitute_tm (Constraints.resolve cst) x in
-  x
-
-let ty c ty =
-  try
-    let c = preprocess_ctx c in
-    let ty = preprocess_ty c ty in
-    let c = ctx c in
-    let ty, meta_ctx = Translate_raw.ty ty in
-    let elab_fn ty = elab_ty c meta_ctx ty in
-    let print_fn = Printing.ty_to_string in
-    (c, solve_cst ~elab_fn ~print_fn ~kind:"type" ty)
-  with Error.UnknownId s -> raise (Error.unknown_id s)
-
-let tm c tm =
-  try
-    let c = preprocess_ctx c in
-    let tm = preprocess_tm c tm in
-    let c = ctx c in
-    let tm, meta_ctx = Translate_raw.tm tm in
-    let elab_fn tm = elab_tm c meta_ctx tm in
-    let print_fn = Printing.tm_to_string in
-    (c, solve_cst ~elab_fn ~print_fn ~kind:"term" tm)
-  with Error.UnknownId s -> raise (Error.unknown_id s)
-
-let ty_in_ps ps t =
-  try
-    let ps = preprocess_ctx ps in
-    let t = preprocess_ty ps t in
-    let ps = ctx ps in
-    let t, meta_ctx = Translate_raw.ty t in
-    let t =
-      let elab_fn ty = elab_ty ps meta_ctx ty in
-      solve_cst ~elab_fn ~print_fn:Printing.ty_to_string ~kind:"type" t
-    in
+      let ty = preprocess_ty c ty in
+      let c = ctx c in
+      let ty, meta_ctx = Translate_raw.ty ty in
+      let elab_fn ty = elab_ty c meta_ctx ty in
+      let print_fn = Printing.ty_to_string in
+      (c, solve_cst ~elab_fn ~print_fn ~kind:"type" ty)
+    with Error.UnknownId s -> raise (Error.unknown_id s)
+
+  let tm c tm =
     try
-      let _, names, _ = Unchecked.db_levels ps in
-      ( Kernel.PS.(forget (mk (Kernel.Ctx.check ps))),
-        Unchecked.rename_ty t names )
-    with
-    | Kernel.PS.Invalid -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
-    | DoubledVar x -> raise (Error.doubled_var (Printing.ctx_to_string ps) x)
-  with Error.UnknownId s -> raise (Error.unknown_id s)
+      let c = preprocess_ctx c in
+      let tm = preprocess_tm c tm in
+      let c = ctx c in
+      let tm, meta_ctx = Translate_raw.tm tm in
+      let elab_fn tm = elab_tm c meta_ctx tm in
+      let print_fn = Printing.tm_to_string in
+      (c, solve_cst ~elab_fn ~print_fn ~kind:"term" tm)
+    with Error.UnknownId s -> raise (Error.unknown_id s)
+
+  let ty_in_ps ps t =
+    try
+      let ps = preprocess_ctx ps in
+      let t = preprocess_ty ps t in
+      let ps = ctx ps in
+      let t, meta_ctx = Translate_raw.ty t in
+      let t =
+        let elab_fn ty = elab_ty ps meta_ctx ty in
+        solve_cst ~elab_fn ~print_fn:Printing.ty_to_string ~kind:"type" t
+      in
+      try
+        let _, names, _ = Unchecked.db_levels ps in
+        (PS.(forget (mk (Ctx.check ps))), Unchecked.rename_ty t names)
+      with
+      | PS.Invalid -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
+      | DoubledVar x -> raise (Error.doubled_var (Printing.ctx_to_string ps) x)
+    with Error.UnknownId s -> raise (Error.unknown_id s)
+end
diff --git a/lib/elaboration/elaborate.mli b/lib/elaboration/elaborate.mli
index 48e089ac..acd81e95 100644
--- a/lib/elaboration/elaborate.mli
+++ b/lib/elaboration/elaborate.mli
@@ -1,8 +1,11 @@
 open Common
-open Kernel
 open Raw_types
 
-val ctx : (Var.t * tyR) list -> ctx
-val ty : (Var.t * tyR) list -> tyR -> ctx * ty
-val tm : (Var.t * tyR) list -> tmR -> ctx * tm
-val ty_in_ps : (Var.t * tyR) list -> tyR -> ps * ty
+module Make (Environment : Environments.S) : sig
+  open Environment
+
+  val ctx : (Var.t * tyR) list -> ctx
+  val ty : (Var.t * tyR) list -> tyR -> ctx * ty
+  val tm : (Var.t * tyR) list -> tmR -> ctx * tm
+  val ty_in_ps : (Var.t * tyR) list -> tyR -> ps * ty
+end
diff --git a/lib/elaboration/translate_raw.ml b/lib/elaboration/translate_raw.ml
index 7e5420c8..3016ab53 100644
--- a/lib/elaboration/translate_raw.ml
+++ b/lib/elaboration/translate_raw.ml
@@ -1,184 +1,188 @@
-open Kernel
 open Raw_types
 open Common
 
 exception WrongNumberOfArguments
 
-let rec head_susp = function
-  | VarR _ -> 0
-  | Sub (_, _, None, _) -> 0
-  | Sub (_, _, Some susp, _) -> susp
-  | Op (_, t) | Inverse t | Unit t -> head_susp t
-  | Meta | BuiltinR _ | Letin_tm _ -> Error.fatal "ill-formed term"
+module Make (Environment : Environments.S) = struct
+  module RawElab = Raw.Make (Environment)
+  open Environment
 
-(* inductive translation on terms and types without let_in *)
-let rec tm t =
-  let make_coh coh s susp expl =
-    let coh = Suspension.coh susp coh in
-    let ps, _, _ = Coh.forget coh in
-    let func = find_functorialisation s (Unchecked.ps_to_ctx ps) expl in
-    let t = Functorialisation.coh_successively coh func in
-    let ctx = Tm.ctx t in
-    let s, meta_types = sub s ctx expl in
-    (App (t, s), meta_types)
-  in
-  let make_app tm s susp expl =
-    let tm = Suspension.checked_tm susp tm in
-    let ctx = Tm.ctx tm in
-    let func = find_functorialisation s ctx expl in
-    let t = Functorialisation.tm tm func in
-    let ctx = Tm.ctx t in
-    let s, meta_types = sub s ctx expl in
-    (App (t, s), meta_types)
-  in
-  match t with
-  | VarR v -> (Var v, [])
-  | Sub (VarR v, s, susp, expl) -> (
-      match Environment.val_var v with
-      | Coh coh -> make_coh coh s susp expl
-      | Tm t ->
-          let t = Suspension.checked_tm susp t in
-          let c = Tm.ctx t in
-          let func = find_functorialisation s c expl in
-          let t = Functorialisation.tm t func in
-          let c = Tm.ctx t in
-          let s, meta_types = sub s c expl in
-          (App (t, s), meta_types))
-  | Sub (BuiltinR b, s, susp, expl) -> (
-      match b with
-      | Comp ->
-          let coh = Builtin.comp s expl in
-          make_coh coh s susp expl
-      | Id ->
-          let coh = Builtin.id () in
-          make_coh coh s susp expl
-      | Conecomp (n, k, m) ->
-          let tm = Cones.compose n m k in
-          make_app tm s susp expl
-      | Cylcomp (n, k, m) ->
-          let tm = Cylinders.compose n m k in
-          make_app tm s susp expl
-      | Cylstack n ->
-          let tm = Cylinders.stacking n in
-          make_app tm s susp expl
-      | Eh_half (n, k, l) ->
-          let tm = Eh.eh n k l in
-          make_app tm s susp expl
-      | Eh_full (n, k, l) ->
-          let tm = Eh.full_eh n k l in
-          make_app tm s susp expl)
-  | Op (l, t) ->
-      let offset = head_susp t in
-      let t, meta = tm t in
-      (Opposite.tm t (List.map (fun x -> x + offset) l), meta)
-  | Inverse t ->
-      let t, meta_ctx = tm t in
-      (Inverse.compute_inverse t, meta_ctx)
-  | Unit t ->
-      let t, meta_ctx = tm t in
-      (Inverse.compute_witness t, meta_ctx)
-  | Meta ->
-      let m, meta_type = Meta.new_tm () in
-      (m, [ meta_type ])
-  | Sub (Letin_tm _, _, _, _)
-  | Sub (Sub _, _, _, _)
-  | Sub (Meta, _, _, _)
-  | Sub (Op _, _, _, _)
-  | Sub (Inverse _, _, _, _)
-  | Sub (Unit _, _, _, _)
-  | BuiltinR _ | Letin_tm _ ->
-      Error.fatal "ill-formed term"
+  let rec head_susp = function
+    | VarR _ -> 0
+    | Sub (_, _, None, _) -> 0
+    | Sub (_, _, Some susp, _) -> susp
+    | Op (_, t) | Inverse t | Unit t -> head_susp t
+    | Meta | BuiltinR _ | Letin_tm _ -> Error.fatal "ill-formed term"
 
-and sub s tgt expl =
-  match (s, tgt) with
-  | [], [] -> ([], [])
-  | (t, i) :: s, (x, (_, e)) :: tgt
-    when e || expl || !Settings.explicit_substitutions ->
-      let t, meta_types_t = tm t in
-      let fmetas, meta_types_f, tgt = meta_functed_arg i tgt in
-      let s, meta_types_s = sub s tgt expl in
-      let meta_types =
-        List.concat [ meta_types_t; meta_types_f; meta_types_s ]
-      in
-      ((x, (t, e)) :: List.append fmetas s, meta_types)
-  | (_ :: _ as s), (x, (_, e)) :: tgt ->
-      let t, meta_type = Meta.new_tm () in
-      let s, meta_types_s = sub s tgt expl in
-      ((x, (t, e)) :: s, meta_type :: meta_types_s)
-  | [], (x, (_, false)) :: tgt ->
-      let t, meta_type = Meta.new_tm () in
-      let s, meta_types_s = sub [] tgt expl in
-      ((x, (t, false)) :: s, meta_type :: meta_types_s)
-  | _ :: _, [] | [], _ :: _ -> raise WrongNumberOfArguments
+  (* inductive translation on terms and types without let_in *)
+  let rec tm t =
+    let make_coh coh s susp expl =
+      let coh = Suspension.coh susp coh in
+      let ps, _, _ = Coh.forget coh in
+      let func = find_functorialisation s (Unchecked.ps_to_ctx ps) expl in
+      let t = Functorialisation.coh_successively coh func in
+      let ctx = Tm.ctx t in
+      let s, meta_types = sub s ctx expl in
+      (App (t, s), meta_types)
+    in
+    let make_app tm s susp expl =
+      let tm = Suspension.checked_tm susp tm in
+      let ctx = Tm.ctx tm in
+      let func = find_functorialisation s ctx expl in
+      let t = Functorialisation.tm tm func in
+      let ctx = Tm.ctx t in
+      let s, meta_types = sub s ctx expl in
+      (App (t, s), meta_types)
+    in
+    match t with
+    | VarR v -> (Var v, [])
+    | Sub (VarR v, s, susp, expl) -> (
+        match Environment.val_var v with
+        | Coh coh -> make_coh coh s susp expl
+        | Tm t ->
+            let t = Suspension.checked_tm susp t in
+            let c = Tm.ctx t in
+            let func = find_functorialisation s c expl in
+            let t = Functorialisation.tm t func in
+            let c = Tm.ctx t in
+            let s, meta_types = sub s c expl in
+            (App (t, s), meta_types))
+    | Sub (BuiltinR b, s, susp, expl) -> (
+        match b with
+        | Comp ->
+            let coh = Builtin.comp s expl in
+            make_coh coh s susp expl
+        | Id ->
+            let coh = Builtin.id () in
+            make_coh coh s susp expl
+        | Conecomp (n, k, m) ->
+            let tm = Cones.compose n m k in
+            make_app tm s susp expl
+        | Cylcomp (n, k, m) ->
+            let tm = Cylinders.compose n m k in
+            make_app tm s susp expl
+        | Cylstack n ->
+            let tm = Cylinders.stacking n in
+            make_app tm s susp expl
+        | Eh_half (n, k, l) ->
+            let tm = Eh.eh n k l in
+            make_app tm s susp expl
+        | Eh_full (n, k, l) ->
+            let tm = Eh.full_eh n k l in
+            make_app tm s susp expl)
+    | Op (l, t) ->
+        let offset = head_susp t in
+        let t, meta = tm t in
+        (Opposite.tm t (List.map (fun x -> x + offset) l), meta)
+    | Inverse t ->
+        let t, meta_ctx = tm t in
+        (Inverse.compute_inverse t, meta_ctx)
+    | Unit t ->
+        let t, meta_ctx = tm t in
+        (Inverse.compute_witness t, meta_ctx)
+    | Meta ->
+        let m, meta_type = Meta.new_tm () in
+        (m, [ meta_type ])
+    | Sub (Letin_tm _, _, _, _)
+    | Sub (Sub _, _, _, _)
+    | Sub (Meta, _, _, _)
+    | Sub (Op _, _, _, _)
+    | Sub (Inverse _, _, _, _)
+    | Sub (Unit _, _, _, _)
+    | BuiltinR _ | Letin_tm _ ->
+        Error.fatal "ill-formed term"
 
-and find_functorialisation s tgt expl =
-  match (s, tgt) with
-  | [], [] -> []
-  | (_, i) :: s, (x, (_, e)) :: tgt
-    when e || expl || !Settings.explicit_substitutions ->
-      (x, i) :: find_functorialisation s tgt expl
-  | (_ :: _ as s), (_, (_, _)) :: tgt -> find_functorialisation s tgt expl
-  | [], (_, (_, false)) :: _ -> []
-  | _ :: _, [] | [], _ :: _ -> raise WrongNumberOfArguments
+  and sub s tgt expl =
+    match (s, tgt) with
+    | [], [] -> ([], [])
+    | (t, i) :: s, (x, (_, e)) :: tgt
+      when e || expl || !Settings.explicit_substitutions ->
+        let t, meta_types_t = tm t in
+        let fmetas, meta_types_f, tgt = meta_functed_arg i tgt in
+        let s, meta_types_s = sub s tgt expl in
+        let meta_types =
+          List.concat [ meta_types_t; meta_types_f; meta_types_s ]
+        in
+        ((x, (t, e)) :: List.append fmetas s, meta_types)
+    | (_ :: _ as s), (x, (_, e)) :: tgt ->
+        let t, meta_type = Meta.new_tm () in
+        let s, meta_types_s = sub s tgt expl in
+        ((x, (t, e)) :: s, meta_type :: meta_types_s)
+    | [], (x, (_, false)) :: tgt ->
+        let t, meta_type = Meta.new_tm () in
+        let s, meta_types_s = sub [] tgt expl in
+        ((x, (t, false)) :: s, meta_type :: meta_types_s)
+    | _ :: _, [] | [], _ :: _ -> raise WrongNumberOfArguments
 
-and meta_functed_arg i ctx =
-  match (i, ctx) with
-  | 0, tgt -> ([], [], tgt)
-  | _, (y, _) :: (x, _) :: ctx ->
-      let src, meta_types_src = Meta.new_tm () in
-      let tgt, meta_types_tgt = Meta.new_tm () in
-      let fmetas, meta_types, ctx = meta_functed_arg (i - 1) ctx in
-      ( (y, (tgt, false)) :: (x, (src, false)) :: fmetas,
-        meta_types_tgt :: meta_types_src :: meta_types,
-        ctx )
-  | _, _ -> raise WrongNumberOfArguments
+  and find_functorialisation s tgt expl =
+    match (s, tgt) with
+    | [], [] -> []
+    | (_, i) :: s, (x, (_, e)) :: tgt
+      when e || expl || !Settings.explicit_substitutions ->
+        (x, i) :: find_functorialisation s tgt expl
+    | (_ :: _ as s), (_, (_, _)) :: tgt -> find_functorialisation s tgt expl
+    | [], (_, (_, false)) :: _ -> []
+    | _ :: _, [] | [], _ :: _ -> raise WrongNumberOfArguments
 
-let tm t =
-  try tm t
-  with WrongNumberOfArguments ->
-    Error.parsing_error
-      ("term: " ^ Raw.string_of_tm t)
-      "wrong number of arguments provided"
+  and meta_functed_arg i ctx =
+    match (i, ctx) with
+    | 0, tgt -> ([], [], tgt)
+    | _, (y, _) :: (x, _) :: ctx ->
+        let src, meta_types_src = Meta.new_tm () in
+        let tgt, meta_types_tgt = Meta.new_tm () in
+        let fmetas, meta_types, ctx = meta_functed_arg (i - 1) ctx in
+        ( (y, (tgt, false)) :: (x, (src, false)) :: fmetas,
+          meta_types_tgt :: meta_types_src :: meta_types,
+          ctx )
+    | _, _ -> raise WrongNumberOfArguments
 
-let ty ty =
-  match ty with
-  | ObjR -> (Obj, [])
-  | ArrR (u, v) ->
-      let (tu, meta_types_tu), (tv, meta_types_tv) = (tm u, tm v) in
-      (Arr (Meta.new_ty (), tu, tv), List.append meta_types_tu meta_types_tv)
-  | Letin_ty _ -> Error.fatal "letin_ty constructor cannot appear here"
+  let tm t =
+    try tm t
+    with WrongNumberOfArguments ->
+      Error.parsing_error
+        ("term: " ^ Raw.string_of_tm t)
+        "wrong number of arguments provided"
 
-let ty t =
-  try ty t
-  with WrongNumberOfArguments ->
-    Error.parsing_error
-      ("type: " ^ Raw.string_of_ty t)
-      "wrong number of arguments provided"
+  let ty ty =
+    match ty with
+    | ObjR -> (Obj, [])
+    | ArrR (u, v) ->
+        let (tu, meta_types_tu), (tv, meta_types_tv) = (tm u, tm v) in
+        (Arr (Meta.new_ty (), tu, tv), List.append meta_types_tu meta_types_tv)
+    | Letin_ty _ -> Error.fatal "letin_ty constructor cannot appear here"
 
-let ctx c =
-  let rec mark_explicit c after =
-    match c with
-    | [] -> []
-    | (v, t) :: c ->
-        let expl =
-          not (List.exists (fun (_, ty) -> Raw.var_in_ty v ty) after)
-        in
-        (v, (t, expl)) :: mark_explicit c ((v, t) :: after)
-  in
-  let rec list c =
-    match c with
-    | [] -> ([], [])
-    | (v, (t, expl)) :: c ->
-        let c, meta_c = list c in
-        let t, meta_ty = ty t in
-        ((v, (t, expl)) :: c, List.append meta_ty meta_c)
-  in
-  list (mark_explicit c [])
+  let ty t =
+    try ty t
+    with WrongNumberOfArguments ->
+      Error.parsing_error
+        ("type: " ^ Raw.string_of_ty t)
+        "wrong number of arguments provided"
+
+  let ctx c =
+    let rec mark_explicit c after =
+      match c with
+      | [] -> []
+      | (v, t) :: c ->
+          let expl =
+            not (List.exists (fun (_, ty) -> RawElab.var_in_ty v ty) after)
+          in
+          (v, (t, expl)) :: mark_explicit c ((v, t) :: after)
+    in
+    let rec list c =
+      match c with
+      | [] -> ([], [])
+      | (v, (t, expl)) :: c ->
+          let c, meta_c = list c in
+          let t, meta_ty = ty t in
+          ((v, (t, expl)) :: c, List.append meta_ty meta_c)
+    in
+    list (mark_explicit c [])
 
-let rec sub_to_suspended = function
-  | [] ->
-      let (m1, mc1), (m0, mc0) = (Meta.new_tm (), Meta.new_tm ()) in
-      ([ (m1, false); (m0, false) ], [ mc1; mc0 ])
-  | t :: s ->
-      let s, m = sub_to_suspended s in
-      (t :: s, m)
+  let rec sub_to_suspended = function
+    | [] ->
+        let (m1, mc1), (m0, mc0) = (Meta.new_tm (), Meta.new_tm ()) in
+        ([ (m1, false); (m0, false) ], [ mc1; mc0 ])
+    | t :: s ->
+        let s, m = sub_to_suspended s in
+        (t :: s, m)
+end
diff --git a/lib/elaboration/translate_raw.mli b/lib/elaboration/translate_raw.mli
index f59abe0b..f1f4b5ae 100644
--- a/lib/elaboration/translate_raw.mli
+++ b/lib/elaboration/translate_raw.mli
@@ -1,8 +1,11 @@
 open Common
-open Kernel
 open Raw_types
 
-val tm : tmR -> tm * meta_ctx
-val ty : tyR -> ty * meta_ctx
-val ctx : (Var.t * tyR) list -> ctx * meta_ctx
-val sub_to_suspended : sub_ps -> sub_ps * meta_ctx
+module Make (Environment : Environments.S) : sig
+  open Environment
+
+  val tm : tmR -> tm * meta_ctx
+  val ty : tyR -> ty * meta_ctx
+  val ctx : (Var.t * tyR) list -> ctx * meta_ctx
+  val sub_to_suspended : sub_ps -> sub_ps * meta_ctx
+end
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index a43bb086..9ed7363d 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -6,847 +6,855 @@ exception IsCoh
 exception InvalidSubTarget of string * string
 exception MetaVariable
 
-(** Operations on substitutions. *)
-module rec Sub : sig
-  type t
-
-  val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
-  val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> t
-  val forget : t -> (Coh.t, Tm.t) sub
-  val free_vars : t -> Var.t list
-  val src : t -> Ctx.t
-  val tgt : t -> Ctx.t
-end = struct
-  type t = {
-    list : Tm.t list;
-    src : Ctx.t;
-    tgt : Ctx.t;
-    unchecked : (Coh.t, Tm.t) sub;
-  }
-
-  let src s = s.src
-  let tgt s = s.tgt
-
-  module Core = struct
-    module Coh = Coh
-    module Tm = Tm
-  end
-
-  open Syntax.Make (Core)
-
-  let tbl : (Ctx.t * PS.t * sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
-  let free_vars s = List.concat (List.map Tm.free_vars s.list)
-
-  let check src s tgt =
-    Io.info ~v:5
-      (lazy
-        (Printf.sprintf
-           "building kernel substitution : source = %s; substitution = %s; \
-            target = %s"
-           (Ctx.to_string src) (Printing.sub_to_string s) (Ctx.to_string tgt)));
-    let sub_exn =
-      InvalidSubTarget (Printing.sub_to_string_debug s, Ctx.to_string tgt)
-    in
-    let rec aux src s tgt =
-      let expr s tgt =
-        match (s, Ctx.value tgt) with
-        | [], [] -> []
-        | _ :: _, [] | [], _ :: _ -> raise sub_exn
-        | (x1, _) :: _, (x2, _) :: _ when x1 <> x2 -> raise sub_exn
-        | (_, (t, _)) :: s, (_, a) :: _ ->
-            let sub = aux src s (Ctx.tail tgt) in
-            let t = Tm.check src t in
-            Ty.check_equal (Tm.typ t) (Ty.apply_sub a sub);
-            t :: sub.list
-      in
-      { list = expr s tgt; src; tgt; unchecked = s }
-    in
-    aux src s tgt
-
-  let check_to_ps src s tgt_ps =
-    match Hashtbl.find_opt tbl (src, tgt_ps, s) with
-    | Some sub -> sub
-    | None ->
-        let tgt = PS.to_ctx tgt_ps in
-        let s_assoc =
-          try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) (Ctx.value tgt) s
-          with Invalid_argument _ ->
-            Error.fatal "uncaught wrong number of arguments"
-        in
-        let sub = check src s_assoc tgt in
-        Hashtbl.add tbl (src, tgt_ps, s) sub;
-        sub
+module Make (_ : Theory.S) = struct
+  (** Operations on substitutions. *)
+  module rec Sub : sig
+    type t
+
+    val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
+    val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> t
+    val forget : t -> (Coh.t, Tm.t) sub
+    val free_vars : t -> Var.t list
+    val src : t -> Ctx.t
+    val tgt : t -> Ctx.t
+  end = struct
+    type t = {
+      list : Tm.t list;
+      src : Ctx.t;
+      tgt : Ctx.t;
+      unchecked : (Coh.t, Tm.t) sub;
+    }
 
-  let forget s = s.unchecked
-end
+    let src s = s.src
+    let tgt s = s.tgt
 
-(** A context, associating a type to each context variable. *)
-and Ctx : sig
-  type t
-
-  val empty : unit -> t
-  val tail : t -> t
-  val to_string : t -> string
-  val ty_var : t -> Var.t -> Ty.t
-  val domain : t -> Var.t list
-  val value : t -> (Var.t * Ty.t) list
-  val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
-  val forget : t -> (Coh.t, Tm.t) ctx
-  val check : (Coh.t, Tm.t) ctx -> t
-  val check_notin : t -> Var.t -> unit
-  val is_equal : t -> t -> bool
-  val check_equal : t -> t -> unit
-end = struct
-  type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
+    module Core = struct
+      module Coh = Coh
+      module Tm = Tm
+    end
 
-  module Core = struct
-    module Coh = Coh
-    module Tm = Tm
-  end
+    open Syntax.Make (Core)
 
-  open Syntax.Make (Core)
-
-  let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
-
-  let tail ctx =
-    match (ctx.c, ctx.unchecked) with
-    | [], (_ :: _ | []) -> Error.fatal "computing tail of an empty context"
-    | _ :: _, [] -> Error.fatal "safe and unchecked context out of sync"
-    | _ :: c, _ :: unchecked -> { c; unchecked }
-
-  let ty_var ctx x =
-    try List.assoc x ctx.c
-    with Not_found -> raise (Error.UnknownId (Var.to_string x))
-
-  let empty () = { c = []; unchecked = [] }
-  let domain ctx = List.map fst ctx.c
-  let value ctx = ctx.c
-  let forget c = c.unchecked
-  let to_string ctx = Printing.ctx_to_string (forget ctx)
-
-  let is_equal ctx1 ctx2 =
-    ctx1 == ctx2 || Equality.is_equal_ctx (forget ctx1) (forget ctx2)
-
-  let check_equal ctx1 ctx2 =
-    if not (is_equal ctx1 ctx2) then
-      raise
-        (NotEqual
-           ( Printing.ctx_to_string (forget ctx1),
-             Printing.ctx_to_string (forget ctx2) ))
-
-  let check_notin ctx x =
-    try
-      ignore (List.assoc x ctx.c);
-      raise (DoubledVar (Var.to_string x))
-    with Not_found -> ()
-
-  let extend ctx ~expl x t =
-    let ty = Ty.check ctx t in
-    Ctx.check_notin ctx x;
-    {
-      c = (x, ty) :: Ctx.value ctx;
-      unchecked = (x, (t, expl)) :: Ctx.forget ctx;
-    }
+    let tbl : (Ctx.t * PS.t * sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
+    let free_vars s = List.concat (List.map Tm.free_vars s.list)
 
-  let check c =
-    match Hashtbl.find_opt tbl c with
-    | Some ctx -> ctx
-    | None ->
-        let ctx =
-          List.fold_right
-            (fun (x, (t, expl)) c -> Ctx.extend ~expl c x t)
-            c (Ctx.empty ())
+    let check src s tgt =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf
+             "building kernel substitution : source = %s; substitution = %s; \
+              target = %s"
+             (Ctx.to_string src) (Printing.sub_to_string s) (Ctx.to_string tgt)));
+      let sub_exn =
+        InvalidSubTarget (Printing.sub_to_string_debug s, Ctx.to_string tgt)
+      in
+      let rec aux src s tgt =
+        let expr s tgt =
+          match (s, Ctx.value tgt) with
+          | [], [] -> []
+          | _ :: _, [] | [], _ :: _ -> raise sub_exn
+          | (x1, _) :: _, (x2, _) :: _ when x1 <> x2 -> raise sub_exn
+          | (_, (t, _)) :: s, (_, a) :: _ ->
+              let sub = aux src s (Ctx.tail tgt) in
+              let t = Tm.check src t in
+              Ty.check_equal (Tm.typ t) (Ty.apply_sub a sub);
+              t :: sub.list
         in
-        Hashtbl.add tbl c ctx;
-        ctx
-end
-
-(** Operations on pasting schemes. *)
-and PS : sig
-  exception Invalid
-
-  type t
-
-  val to_string : t -> string
-  val mk : Ctx.t -> t
-  val to_ctx : t -> Ctx.t
-  val bdry : t -> t
-  val source : t -> Sub.t
-  val target : t -> Sub.t
-  val forget : t -> ps
-  val is_equal : t -> t -> bool
-end = struct
-  exception Invalid
+        { list = expr s tgt; src; tgt; unchecked = s }
+      in
+      aux src s tgt
+
+    let check_to_ps src s tgt_ps =
+      match Hashtbl.find_opt tbl (src, tgt_ps, s) with
+      | Some sub -> sub
+      | None ->
+          let tgt = PS.to_ctx tgt_ps in
+          let s_assoc =
+            try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) (Ctx.value tgt) s
+            with Invalid_argument _ ->
+              Error.fatal "uncaught wrong number of arguments"
+          in
+          let sub = check src s_assoc tgt in
+          Hashtbl.add tbl (src, tgt_ps, s) sub;
+          sub
 
-  module Core = struct
-    module Coh = Coh
-    module Tm = Tm
+    let forget s = s.unchecked
   end
 
-  open Syntax.Make (Core)
-
-  (** A pasting scheme. *)
-  type ps_derivation =
-    | PNil of (Var.t * Ty.t)
-    | PCons of ps_derivation * (Var.t * Ty.t) * (Var.t * Ty.t)
-    | PDrop of ps_derivation
-
-  type t = { tree : ps; ctx : Ctx.t }
-
-  (* TODO:fix level of explicitness here *)
+  (** A context, associating a type to each context variable. *)
+  and Ctx : sig
+    type t
+
+    val empty : unit -> t
+    val tail : t -> t
+    val to_string : t -> string
+    val ty_var : t -> Var.t -> Ty.t
+    val domain : t -> Var.t list
+    val value : t -> (Var.t * Ty.t) list
+    val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
+    val forget : t -> (Coh.t, Tm.t) ctx
+    val check : (Coh.t, Tm.t) ctx -> t
+    val check_notin : t -> Var.t -> unit
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+  end = struct
+    type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
+
+    module Core = struct
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
+
+    let tail ctx =
+      match (ctx.c, ctx.unchecked) with
+      | [], (_ :: _ | []) -> Error.fatal "computing tail of an empty context"
+      | _ :: _, [] -> Error.fatal "safe and unchecked context out of sync"
+      | _ :: c, _ :: unchecked -> { c; unchecked }
+
+    let ty_var ctx x =
+      try List.assoc x ctx.c
+      with Not_found -> raise (Error.UnknownId (Var.to_string x))
+
+    let empty () = { c = []; unchecked = [] }
+    let domain ctx = List.map fst ctx.c
+    let value ctx = ctx.c
+    let forget c = c.unchecked
+    let to_string ctx = Printing.ctx_to_string (forget ctx)
+
+    let is_equal ctx1 ctx2 =
+      ctx1 == ctx2 || Equality.is_equal_ctx (forget ctx1) (forget ctx2)
+
+    let check_equal ctx1 ctx2 =
+      if not (is_equal ctx1 ctx2) then
+        raise
+          (NotEqual
+             ( Printing.ctx_to_string (forget ctx1),
+               Printing.ctx_to_string (forget ctx2) ))
+
+    let check_notin ctx x =
+      try
+        ignore (List.assoc x ctx.c);
+        raise (DoubledVar (Var.to_string x))
+      with Not_found -> ()
+
+    let extend ctx ~expl x t =
+      let ty = Ty.check ctx t in
+      Ctx.check_notin ctx x;
+      {
+        c = (x, ty) :: Ctx.value ctx;
+        unchecked = (x, (t, expl)) :: Ctx.forget ctx;
+      }
+
+    let check c =
+      match Hashtbl.find_opt tbl c with
+      | Some ctx -> ctx
+      | None ->
+          let ctx =
+            List.fold_right
+              (fun (x, (t, expl)) c -> Ctx.extend ~expl c x t)
+              c (Ctx.empty ())
+          in
+          Hashtbl.add tbl c ctx;
+          ctx
+  end
 
-  let tbl : (Ctx.t, PS.t) Hashtbl.t = Hashtbl.create 7829
+  (** Operations on pasting schemes. *)
+  and PS : sig
+    exception Invalid
+
+    type t
+
+    val to_string : t -> string
+    val mk : Ctx.t -> t
+    val to_ctx : t -> Ctx.t
+    val bdry : t -> t
+    val source : t -> Sub.t
+    val target : t -> Sub.t
+    val forget : t -> ps
+    val is_equal : t -> t -> bool
+  end = struct
+    exception Invalid
+
+    module Core = struct
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    (** A pasting scheme. *)
+    type ps_derivation =
+      | PNil of (Var.t * Ty.t)
+      | PCons of ps_derivation * (Var.t * Ty.t) * (Var.t * Ty.t)
+      | PDrop of ps_derivation
+
+    type t = { tree : ps; ctx : Ctx.t }
+
+    (* TODO:fix level of explicitness here *)
+
+    let tbl : (Ctx.t, PS.t) Hashtbl.t = Hashtbl.create 7829
+
+    (** Create a context from a pasting scheme. *)
+    let old_rep_to_ctx ps =
+      let rec list ps =
+        match ps with
+        | PDrop ps -> list ps
+        | PCons (ps, (x1, t1), (x2, t2)) ->
+            (x2, (Ty.forget t2, true)) :: (x1, (Ty.forget t1, true)) :: list ps
+        | PNil (x, t) -> [ (x, (Ty.forget t, true)) ]
+      in
+      Ctx.check (list ps)
 
-  (** Create a context from a pasting scheme. *)
-  let old_rep_to_ctx ps =
-    let rec list ps =
+    (** Dangling variable. *)
+    let rec marker (ps : ps_derivation) =
       match ps with
-      | PDrop ps -> list ps
-      | PCons (ps, (x1, t1), (x2, t2)) ->
-          (x2, (Ty.forget t2, true)) :: (x1, (Ty.forget t1, true)) :: list ps
-      | PNil (x, t) -> [ (x, (Ty.forget t, true)) ]
-    in
-    Ctx.check (list ps)
-
-  (** Dangling variable. *)
-  let rec marker (ps : ps_derivation) =
-    match ps with
-    | PNil (x, t) -> (x, t)
-    | PCons (_, _, f) -> f
-    | PDrop ps ->
-        let _, tf = marker ps in
-        let v = try Ty.target tf with IsObj -> raise Invalid in
-        let y = try Tm.to_var v with IsCoh -> raise Invalid in
-        let t =
-          let rec aux = function
-            | PNil (x, t) ->
-                assert (x = y);
-                t
-            | PCons (ps, (y', ty), (f, tf)) ->
-                if y' = y then ty else if f = y then tf else aux ps
-            | PDrop ps -> aux ps
+      | PNil (x, t) -> (x, t)
+      | PCons (_, _, f) -> f
+      | PDrop ps ->
+          let _, tf = marker ps in
+          let v = try Ty.target tf with IsObj -> raise Invalid in
+          let y = try Tm.to_var v with IsCoh -> raise Invalid in
+          let t =
+            let rec aux = function
+              | PNil (x, t) ->
+                  assert (x = y);
+                  t
+              | PCons (ps, (y', ty), (f, tf)) ->
+                  if y' = y then ty else if f = y then tf else aux ps
+              | PDrop ps -> aux ps
+            in
+            aux ps
           in
-          aux ps
-        in
-        (y, t)
+          (y, t)
 
-  (** Create a pasting scheme from a context. *)
-  let make_old (l : Ctx.t) =
-    let rec close ps tx =
-      if Ty.is_obj tx then ps
-      else
-        let tx = Ty.under_type tx in
-        close (PDrop ps) tx
-    in
-    let build l =
-      let x0, ty, l =
-        match l with
-        | (x, ty) :: l when Ty.is_obj ty -> (x, ty, l)
-        | _ -> raise Invalid
+    (** Create a pasting scheme from a context. *)
+    let make_old (l : Ctx.t) =
+      let rec close ps tx =
+        if Ty.is_obj tx then ps
+        else
+          let tx = Ty.under_type tx in
+          close (PDrop ps) tx
       in
-      let rec aux ps = function
-        | (y, ty) :: (f, tf) :: l as l1 ->
-            let _, u, v =
-              try Ty.retrieve_arrow tf with IsObj -> raise Invalid
-            in
-            let fx, fy =
-              try (Tm.to_var u, Tm.to_var v) with IsCoh -> raise Invalid
-            in
-            if y <> fy then raise Invalid;
-            let x, _ = marker ps in
-            if x = fx then (
-              let varps = Ctx.domain (old_rep_to_ctx ps) in
-              if List.mem f varps then raise (DoubledVar (Var.to_string f));
-              if List.mem y varps then raise (DoubledVar (Var.to_string y));
-              let ps = PCons (ps, (y, ty), (f, tf)) in
-              aux ps l)
-            else aux (PDrop ps) l1
-        | [ (_, _) ] -> raise Invalid
-        | [] ->
-            let _, tx = marker ps in
-            close ps tx
+      let build l =
+        let x0, ty, l =
+          match l with
+          | (x, ty) :: l when Ty.is_obj ty -> (x, ty, l)
+          | _ -> raise Invalid
+        in
+        let rec aux ps = function
+          | (y, ty) :: (f, tf) :: l as l1 ->
+              let _, u, v =
+                try Ty.retrieve_arrow tf with IsObj -> raise Invalid
+              in
+              let fx, fy =
+                try (Tm.to_var u, Tm.to_var v) with IsCoh -> raise Invalid
+              in
+              if y <> fy then raise Invalid;
+              let x, _ = marker ps in
+              if x = fx then (
+                let varps = Ctx.domain (old_rep_to_ctx ps) in
+                if List.mem f varps then raise (DoubledVar (Var.to_string f));
+                if List.mem y varps then raise (DoubledVar (Var.to_string y));
+                let ps = PCons (ps, (y, ty), (f, tf)) in
+                aux ps l)
+              else aux (PDrop ps) l1
+          | [ (_, _) ] -> raise Invalid
+          | [] ->
+              let _, tx = marker ps in
+              close ps tx
+        in
+        aux (PNil (x0, ty)) l
       in
-      aux (PNil (x0, ty)) l
-    in
-    build (List.rev (Ctx.value l))
-
-  (* assumes that all ps are completed with enough PDrop in the end *)
-  let make_tree ps =
-    let rec find_previous ps list =
-      match ps with
-      | PNil x -> (Br list, PNil x)
-      | PCons (ps, _, _) -> (Br list, ps)
-      | PDrop _ as ps ->
-          let p, ps = build_till_previous ps in
-          (Br p, ps)
-    and build_till_previous ps =
-      match ps with
-      | PNil x -> ([], PNil x)
-      | PCons (ps, _, _) -> ([], ps)
-      | PDrop ps ->
-          let p, ps = find_previous ps [] in
-          let prev, ps = build_till_previous ps in
-          (p :: prev, ps)
-    in
-    Br (fst (build_till_previous ps))
+      build (List.rev (Ctx.value l))
+
+    (* assumes that all ps are completed with enough PDrop in the end *)
+    let make_tree ps =
+      let rec find_previous ps list =
+        match ps with
+        | PNil x -> (Br list, PNil x)
+        | PCons (ps, _, _) -> (Br list, ps)
+        | PDrop _ as ps ->
+            let p, ps = build_till_previous ps in
+            (Br p, ps)
+      and build_till_previous ps =
+        match ps with
+        | PNil x -> ([], PNil x)
+        | PCons (ps, _, _) -> ([], ps)
+        | PDrop ps ->
+            let p, ps = find_previous ps [] in
+            let prev, ps = build_till_previous ps in
+            (p :: prev, ps)
+      in
+      Br (fst (build_till_previous ps))
 
-  let mk (l : Ctx.t) =
-    match Hashtbl.find_opt tbl l with
-    | Some ps -> ps
-    | None ->
-        let oldrep = make_old l in
-        let ps = { tree = make_tree oldrep; ctx = l } in
-        Hashtbl.add tbl l ps;
-        ps
+    let mk (l : Ctx.t) =
+      match Hashtbl.find_opt tbl l with
+      | Some ps -> ps
+      | None ->
+          let oldrep = make_old l in
+          let ps = { tree = make_tree oldrep; ctx = l } in
+          Hashtbl.add tbl l ps;
+          ps
 
-  let forget ps = ps.tree
-  let to_string ps = Printing.ps_to_string (forget ps)
+    let forget ps = ps.tree
+    let to_string ps = Printing.ps_to_string (forget ps)
 
-  (** Create a context from a pasting scheme. *)
-  let to_ctx ps = ps.ctx
+    (** Create a context from a pasting scheme. *)
+    let to_ctx ps = ps.ctx
 
-  let bdry ps = mk (Ctx.check (Unchecked.ps_to_ctx (Unchecked.ps_bdry ps.tree)))
+    let bdry ps =
+      mk (Ctx.check (Unchecked.ps_to_ctx (Unchecked.ps_bdry ps.tree)))
 
-  let source ps =
-    Sub.check_to_ps (to_ctx ps) (Unchecked.ps_src ps.tree) (bdry ps)
+    let source ps =
+      Sub.check_to_ps (to_ctx ps) (Unchecked.ps_src ps.tree) (bdry ps)
 
-  let target ps =
-    Sub.check_to_ps (to_ctx ps) (Unchecked.ps_tgt ps.tree) (bdry ps)
+    let target ps =
+      Sub.check_to_ps (to_ctx ps) (Unchecked.ps_tgt ps.tree) (bdry ps)
 
-  let is_equal ps1 ps2 =
-    ps1.tree == ps2.tree || Equality.is_equal_ps ps1.tree ps2.tree
-end
+    let is_equal ps1 ps2 =
+      ps1.tree == ps2.tree || Equality.is_equal_ps ps1.tree ps2.tree
+  end
 
-and Ty : sig
-  type t
-
-  val to_string : t -> string
-  val free_vars : t -> Var.t list
-  val is_full : t -> bool
-  val is_obj : t -> bool
-  val is_equal : t -> t -> bool
-  val check_equal : t -> t -> unit
-  val morphism : Tm.t -> Tm.t -> Ty.t
-  val forget : t -> (Coh.t, Tm.t) ty
-  val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
-  val apply_sub : t -> Sub.t -> t
-  val retrieve_arrow : t -> t * Tm.t * Tm.t
-  val under_type : t -> t
-  val source : t -> Tm.t
-  val target : t -> Tm.t
-  val ctx : t -> Ctx.t
-  val dim : t -> int
-end = struct
-  module Core = struct
-    module Coh = Coh
-    module Tm = Tm
+  and Ty : sig
+    type t
+
+    val to_string : t -> string
+    val free_vars : t -> Var.t list
+    val is_full : t -> bool
+    val is_obj : t -> bool
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val morphism : Tm.t -> Tm.t -> Ty.t
+    val forget : t -> (Coh.t, Tm.t) ty
+    val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
+    val apply_sub : t -> Sub.t -> t
+    val retrieve_arrow : t -> t * Tm.t * Tm.t
+    val under_type : t -> t
+    val source : t -> Tm.t
+    val target : t -> Tm.t
+    val ctx : t -> Ctx.t
+    val dim : t -> int
+  end = struct
+    module Core = struct
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    (** A type exepression. *)
+    type expr = Obj | Arr of t * Tm.t * Tm.t
+
+    and t = { c : Ctx.t; e : expr; unchecked : ty }
+
+    let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
+    let is_obj t = t.e = Obj
+
+    let retrieve_arrow ty =
+      match ty.e with Obj -> raise IsObj | Arr (a, u, v) -> (a, u, v)
+
+    let under_type ty =
+      match ty.e with Obj -> raise IsObj | Arr (a, _, _) -> a
+
+    let source ty = match ty.e with Obj -> raise IsObj | Arr (_, u, _) -> u
+    let target ty = match ty.e with Obj -> raise IsObj | Arr (_, _, v) -> v
+
+    let rec check c t =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "building kernel type %s in context %s"
+             (Printing.ty_to_string t) (Ctx.to_string c)));
+      match Hashtbl.find_opt tbl (c, t) with
+      | Some ty -> ty
+      | None ->
+          let e =
+            match t with
+            | Obj -> Obj
+            | Arr (a, u, v) ->
+                let a = check c a in
+                let u = Tm.check c ~ty:a u in
+                let v = Tm.check c ~ty:a v in
+                Arr (a, u, v)
+            | Meta_ty _ -> raise MetaVariable
+          in
+          let ty = { c; e; unchecked = t } in
+          Hashtbl.add tbl (c, t) ty;
+          ty
+
+    (** Free variables of a type. *)
+    let rec free_vars ty =
+      match ty.e with
+      | Obj -> []
+      | Arr (t, u, v) ->
+          List.unions [ free_vars t; Tm.free_vars u; Tm.free_vars v ]
+
+    let is_full t = List.included (Ctx.domain t.c) (free_vars t)
+    let forget t = t.unchecked
+    let to_string ty = Printing.ty_to_string (forget ty)
+
+    let is_equal ty1 ty2 =
+      Ctx.is_equal ty1.c ty2.c && Equality.is_equal_ty (forget ty1) (forget ty2)
+
+    let check_equal ty1 ty2 =
+      if not (is_equal ty1 ty2) then
+        raise
+          (NotEqual
+             ( Printing.ty_to_string (forget ty1),
+               Printing.ty_to_string (forget ty2) ))
+
+    let morphism t1 t2 =
+      let a1 = Tm.typ t1 in
+      let a2 = Tm.typ t2 in
+      check_equal a1 a2;
+      {
+        c = a1.c;
+        e = Arr (a1, t1, t2);
+        unchecked = Arr (forget a1, Tm.forget t1, Tm.forget t2);
+      }
+
+    let apply_sub t s =
+      Ctx.check_equal t.c (Sub.tgt s);
+      check (Sub.src s) (Unchecked.ty_apply_sub (forget t) (Sub.forget s))
+
+    let ctx t = t.c
+    let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
   end
 
-  open Syntax.Make (Core)
-
-  (** A type exepression. *)
-  type expr = Obj | Arr of t * Tm.t * Tm.t
-
-  and t = { c : Ctx.t; e : expr; unchecked : ty }
-
-  let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
-  let is_obj t = t.e = Obj
-
-  let retrieve_arrow ty =
-    match ty.e with Obj -> raise IsObj | Arr (a, u, v) -> (a, u, v)
-
-  let under_type ty = match ty.e with Obj -> raise IsObj | Arr (a, _, _) -> a
-  let source ty = match ty.e with Obj -> raise IsObj | Arr (_, u, _) -> u
-  let target ty = match ty.e with Obj -> raise IsObj | Arr (_, _, v) -> v
-
-  let rec check c t =
-    Io.info ~v:5
-      (lazy
-        (Printf.sprintf "building kernel type %s in context %s"
-           (Printing.ty_to_string t) (Ctx.to_string c)));
-    match Hashtbl.find_opt tbl (c, t) with
-    | Some ty -> ty
-    | None ->
-        let e =
-          match t with
-          | Obj -> Obj
-          | Arr (a, u, v) ->
-              let a = check c a in
-              let u = Tm.check c ~ty:a u in
-              let v = Tm.check c ~ty:a v in
-              Arr (a, u, v)
-          | Meta_ty _ -> raise MetaVariable
-        in
-        let ty = { c; e; unchecked = t } in
-        Hashtbl.add tbl (c, t) ty;
-        ty
-
-  (** Free variables of a type. *)
-  let rec free_vars ty =
-    match ty.e with
-    | Obj -> []
-    | Arr (t, u, v) ->
-        List.unions [ free_vars t; Tm.free_vars u; Tm.free_vars v ]
-
-  let is_full t = List.included (Ctx.domain t.c) (free_vars t)
-  let forget t = t.unchecked
-  let to_string ty = Printing.ty_to_string (forget ty)
-
-  let is_equal ty1 ty2 =
-    Ctx.is_equal ty1.c ty2.c && Equality.is_equal_ty (forget ty1) (forget ty2)
-
-  let check_equal ty1 ty2 =
-    if not (is_equal ty1 ty2) then
-      raise
-        (NotEqual
-           ( Printing.ty_to_string (forget ty1),
-             Printing.ty_to_string (forget ty2) ))
-
-  let morphism t1 t2 =
-    let a1 = Tm.typ t1 in
-    let a2 = Tm.typ t2 in
-    check_equal a1 a2;
-    {
-      c = a1.c;
-      e = Arr (a1, t1, t2);
-      unchecked = Arr (forget a1, Tm.forget t1, Tm.forget t2);
+  (** Operations on terms. *)
+  and Tm : sig
+    type t
+
+    (* Data extraction *)
+    val to_var : t -> Var.t
+    val typ : t -> Ty.t
+    val ty : t -> (Coh.t, Tm.t) ty
+    val bdry : t -> t * t
+    val ctx : t -> (Coh.t, Tm.t) ctx
+    val forget : t -> (Coh.t, Tm.t) tm
+    val constr : t -> (Coh.t, Tm.t) constr
+    val name : t -> string option
+    val full_name : t -> string option
+    val func_data : t -> (Var.t * int) list list option
+    val pp_data : t -> pp_data option
+    val to_string : t -> string
+
+    (* Variable uses *)
+    val free_vars : t -> Var.t list
+    val is_full : t -> bool
+
+    (* Production of terms *)
+    val of_coh : Coh.t -> t
+    val check : Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
+    val apply_sub : t -> Sub.t -> t
+    val preimage : t -> Sub.t -> t
+    val develop : t -> (Coh.t, Tm.t) tm
+
+    val apply :
+      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+      ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) sub
+
+    val is_equal : t -> t -> bool
+  end = struct
+    module Core = struct
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
+
+    and t = {
+      ty : Ty.t;
+      e : expr;
+      unchecked : tm;
+      mutable developped : tm option;
+      name : pp_data option;
     }
 
-  let apply_sub t s =
-    Ctx.check_equal t.c (Sub.tgt s);
-    check (Sub.src s) (Unchecked.ty_apply_sub (forget t) (Sub.forget s))
-
-  let ctx t = t.c
-  let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
-end
-
-(** Operations on terms. *)
-and Tm : sig
-  type t
-
-  (* Data extraction *)
-  val to_var : t -> Var.t
-  val typ : t -> Ty.t
-  val ty : t -> (Coh.t, Tm.t) ty
-  val bdry : t -> t * t
-  val ctx : t -> (Coh.t, Tm.t) ctx
-  val forget : t -> (Coh.t, Tm.t) tm
-  val constr : t -> (Coh.t, Tm.t) constr
-  val name : t -> string option
-  val full_name : t -> string option
-  val func_data : t -> (Var.t * int) list list option
-  val pp_data : t -> pp_data option
-  val to_string : t -> string
-
-  (* Variable uses *)
-  val free_vars : t -> Var.t list
-  val is_full : t -> bool
-
-  (* Production of terms *)
-  val of_coh : Coh.t -> t
-  val check : Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
-  val apply_sub : t -> Sub.t -> t
-  val preimage : t -> Sub.t -> t
-  val develop : t -> (Coh.t, Tm.t) tm
-
-  val apply :
-    ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-    ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t * (Coh.t, Tm.t) sub
-
-  val is_equal : t -> t -> bool
-end = struct
-  module Core = struct
-    module Coh = Coh
-    module Tm = Tm
+    let typ t = t.ty
+    let ty t = Ty.forget t.ty
+    let tbl : (Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
+
+    let free_vars tm =
+      let fvty = Ty.free_vars tm.ty in
+      match tm.e with
+      | Var x -> x :: fvty
+      | Coh (_, sub) | App (_, sub) -> Sub.free_vars sub
+
+    let is_full tm = List.included (Ctx.domain (Ty.ctx tm.ty)) (free_vars tm)
+    let forget tm = tm.unchecked
+    let constr tm = (forget tm, ty tm)
+
+    let check c ?ty ?name t =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "building kernel term %s in context %s"
+             (Printing.tm_to_string t) (Ctx.to_string c)));
+      let tm =
+        match Hashtbl.find_opt tbl (c, t) with
+        | Some tm -> tm
+        | None -> (
+            match t with
+            | Var x ->
+                let e, ty = (Var x, Ty.check c (Ty.forget (Ctx.ty_var c x))) in
+                { ty; e; unchecked = t; developped = Some t; name }
+            | Meta_tm _ -> raise MetaVariable
+            | Coh (coh, s) ->
+                let sub = Sub.check_to_ps c s (Coh.ps coh) in
+                let e, ty = (Coh (coh, sub), Ty.apply_sub (Coh.ty coh) sub) in
+                let tm = { ty; e; unchecked = t; developped = Some t; name } in
+                Hashtbl.add tbl (c, t) tm;
+                tm
+            | App (u, s) ->
+                let ty = Tm.typ u in
+                let sub = Sub.check c s (Ty.ctx ty) in
+                let e, ty = (App (u, sub), Ty.apply_sub ty sub) in
+                let tm = { ty; e; unchecked = t; developped = None; name } in
+                Hashtbl.add tbl (c, t) tm;
+                tm)
+      in
+      match ty with
+      | None -> tm
+      | Some ty ->
+          Ty.check_equal ty tm.ty;
+          tm
+
+    let develop tm =
+      match tm.developped with
+      | Some t -> t
+      | None ->
+          let dev =
+            match tm.e with
+            | Var _ | Coh (_, _) -> tm.unchecked
+            | App (t, s) ->
+                let dt = Tm.develop t in
+                let s = Sub.forget s in
+                Unchecked.tm_apply_sub dt s
+          in
+          tm.developped <- Some dev;
+          dev
+
+    let to_var tm =
+      match tm.e with
+      | Var v -> v
+      | Coh _ -> raise IsCoh
+      | App _ -> (
+          match develop tm with
+          | Var v -> v
+          | Coh _ -> raise IsCoh
+          | App _ | Meta_tm _ -> assert false)
+
+    let apply_sub t sub =
+      Ctx.check_equal (Sub.tgt sub) (Ty.ctx t.ty);
+      let c = Sub.src sub in
+      let ty = Ty.apply_sub t.ty sub in
+      let t = Unchecked.tm_apply_sub (forget t) (Sub.forget sub) in
+      check c ~ty t
+
+    let preimage t sub =
+      Ctx.check_equal (Sub.src sub) (Ty.ctx t.ty);
+      let c = Sub.tgt sub in
+      let t = Unchecked.tm_sub_preimage (forget t) (Sub.forget sub) in
+      check c t
+
+    let is_equal t1 t2 =
+      Ctx.is_equal (Ty.ctx t1.ty) (Ty.ctx t2.ty)
+      && Equality.is_equal_tm t1.unchecked t2.unchecked
+
+    let apply fun_ctx fun_tm fun_pp_data tm =
+      let c = fun_ctx (Ctx.forget (Ty.ctx (typ tm))) in
+      let db_sub = Unchecked.db_level_sub_inv c in
+      let c, _, _ = Unchecked.db_levels c in
+      let c = Ctx.check c in
+      let newexp = Unchecked.tm_apply_sub (fun_tm (forget tm)) db_sub in
+      let name =
+        Option.map
+          (fun pp_data ->
+            Display_maps.pp_data_rename (fun_pp_data pp_data) db_sub)
+          tm.name
+      in
+      (check c ?name newexp, db_sub)
+
+    let bdry t = (Ty.source (typ t), Ty.target (typ t))
+    let ctx t = Ctx.forget (Ty.ctx (typ t))
+    let name t = Option.map Printing.pp_data_to_string t.name
+    let full_name t = Option.map Printing.full_name t.name
+    let func_data t = Option.map (fun (_, _, f) -> f) t.name
+    let pp_data t = t.name
+
+    let to_string t =
+      match full_name t with
+      | Some name -> name
+      | None -> Printing.tm_to_string (forget t)
+
+    let of_coh coh =
+      let ps, _, pp_data = Coh.forget coh in
+      let id = Unchecked.identity_ps ps in
+      let ctx = Unchecked.ps_to_ctx ps in
+      check (Ctx.check ctx) ~name:pp_data (Coh (coh, id))
   end
 
-  open Syntax.Make (Core)
-
-  type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
-
-  and t = {
-    ty : Ty.t;
-    e : expr;
-    unchecked : tm;
-    mutable developped : tm option;
-    name : pp_data option;
-  }
-
-  let typ t = t.ty
-  let ty t = Ty.forget t.ty
-  let tbl : (Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
-
-  let free_vars tm =
-    let fvty = Ty.free_vars tm.ty in
-    match tm.e with
-    | Var x -> x :: fvty
-    | Coh (_, sub) | App (_, sub) -> Sub.free_vars sub
-
-  let is_full tm = List.included (Ctx.domain (Ty.ctx tm.ty)) (free_vars tm)
-  let forget tm = tm.unchecked
-  let constr tm = (forget tm, ty tm)
-
-  let check c ?ty ?name t =
-    Io.info ~v:5
-      (lazy
-        (Printf.sprintf "building kernel term %s in context %s"
-           (Printing.tm_to_string t) (Ctx.to_string c)));
-    let tm =
-      match Hashtbl.find_opt tbl (c, t) with
-      | Some tm -> tm
-      | None -> (
-          match t with
-          | Var x ->
-              let e, ty = (Var x, Ty.check c (Ty.forget (Ctx.ty_var c x))) in
-              { ty; e; unchecked = t; developped = Some t; name }
-          | Meta_tm _ -> raise MetaVariable
-          | Coh (coh, s) ->
-              let sub = Sub.check_to_ps c s (Coh.ps coh) in
-              let e, ty = (Coh (coh, sub), Ty.apply_sub (Coh.ty coh) sub) in
-              let tm = { ty; e; unchecked = t; developped = Some t; name } in
-              Hashtbl.add tbl (c, t) tm;
-              tm
-          | App (u, s) ->
-              let ty = Tm.typ u in
-              let sub = Sub.check c s (Ty.ctx ty) in
-              let e, ty = (App (u, sub), Ty.apply_sub ty sub) in
-              let tm = { ty; e; unchecked = t; developped = None; name } in
-              Hashtbl.add tbl (c, t) tm;
-              tm)
-    in
-    match ty with
-    | None -> tm
-    | Some ty ->
-        Ty.check_equal ty tm.ty;
-        tm
-
-  let develop tm =
-    match tm.developped with
-    | Some t -> t
-    | None ->
-        let dev =
-          match tm.e with
-          | Var _ | Coh (_, _) -> tm.unchecked
-          | App (t, s) ->
-              let dt = Tm.develop t in
-              let s = Sub.forget s in
-              Unchecked.tm_apply_sub dt s
+  (** A coherence. *)
+  and Coh : sig
+    type t
+
+    val ps : t -> PS.t
+    val ty : t -> Ty.t
+    val src : t -> (t, Tm.t) tm
+    val tgt : t -> (t, Tm.t) tm
+    val check : ps -> (t, Tm.t) ty -> pp_data -> t
+    val check_noninv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
+    val check_inv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
+    val to_string : ?unroll:bool -> t -> string
+    val is_inv : t -> bool
+    val noninv_srctgt : t -> (t, Tm.t) tm * (t, Tm.t) tm * (t, Tm.t) ty
+    val forget : t -> ps * (t, Tm.t) ty * pp_data
+    val func_data : t -> (Var.t * int) list list
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val dim : t -> int
+
+    val apply_ps :
+      (ps -> ps) ->
+      ((t, Tm.t) ty -> (t, Tm.t) ty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t
+
+    val apply :
+      ((t, Tm.t) ctx -> (t, Tm.t) ctx) ->
+      ((t, Tm.t) ty -> (t, Tm.t) ty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (t, Tm.t) sub
+  end = struct
+    type cohInv = { ps : PS.t; ty : Ty.t }
+    type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
+    type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
+
+    module Core = struct
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    let tbl : (ps * ty, Coh.t) Hashtbl.t = Hashtbl.create 7829
+    let tbl_inv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
+    let tbl_noninv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
+
+    exception NotAlgebraic
+
+    let ps = function Inv (data, _) -> data.ps | NonInv (data, _) -> data.ps
+
+    let ty = function
+      | Inv (data, _) -> data.ty
+      | NonInv (data, _) -> data.total_ty
+
+    let src c = Tm.forget (Ty.source (ty c))
+    let tgt c = Tm.forget (Ty.target (ty c))
+    let is_inv = function Inv (_, _) -> true | NonInv (_, _) -> false
+
+    let algebraic ps ty name =
+      if Ty.is_full ty then (
+        Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
+        Inv ({ ps; ty }, name))
+      else
+        let _, src, tgt =
+          try Ty.retrieve_arrow ty with IsObj -> raise NotAlgebraic
         in
-        tm.developped <- Some dev;
-        dev
-
-  let to_var tm =
-    match tm.e with
-    | Var v -> v
-    | Coh _ -> raise IsCoh
-    | App _ -> (
-        match develop tm with
-        | Var v -> v
-        | Coh _ -> raise IsCoh
-        | App _ | Meta_tm _ -> assert false)
-
-  let apply_sub t sub =
-    Ctx.check_equal (Sub.tgt sub) (Ty.ctx t.ty);
-    let c = Sub.src sub in
-    let ty = Ty.apply_sub t.ty sub in
-    let t = Unchecked.tm_apply_sub (forget t) (Sub.forget sub) in
-    check c ~ty t
-
-  let preimage t sub =
-    Ctx.check_equal (Sub.src sub) (Ty.ctx t.ty);
-    let c = Sub.tgt sub in
-    let t = Unchecked.tm_sub_preimage (forget t) (Sub.forget sub) in
-    check c t
-
-  let is_equal t1 t2 =
-    Ctx.is_equal (Ty.ctx t1.ty) (Ty.ctx t2.ty)
-    && Equality.is_equal_tm t1.unchecked t2.unchecked
-
-  let apply fun_ctx fun_tm fun_pp_data tm =
-    let c = fun_ctx (Ctx.forget (Ty.ctx (typ tm))) in
-    let db_sub = Unchecked.db_level_sub_inv c in
-    let c, _, _ = Unchecked.db_levels c in
-    let c = Ctx.check c in
-    let newexp = Unchecked.tm_apply_sub (fun_tm (forget tm)) db_sub in
-    let name =
-      Option.map
-        (fun pp_data ->
-          Display_maps.pp_data_rename (fun_pp_data pp_data) db_sub)
-        tm.name
-    in
-    (check c ?name newexp, db_sub)
-
-  let bdry t = (Ty.source (typ t), Ty.target (typ t))
-  let ctx t = Ctx.forget (Ty.ctx (typ t))
-  let name t = Option.map Printing.pp_data_to_string t.name
-  let full_name t = Option.map Printing.full_name t.name
-  let func_data t = Option.map (fun (_, _, f) -> f) t.name
-  let pp_data t = t.name
-
-  let to_string t =
-    match full_name t with
-    | Some name -> name
-    | None -> Printing.tm_to_string (forget t)
-
-  let of_coh coh =
-    let ps, _, pp_data = Coh.forget coh in
-    let id = Unchecked.identity_ps ps in
-    let ctx = Unchecked.ps_to_ctx ps in
-    check (Ctx.check ctx) ~name:pp_data (Coh (coh, id))
-end
-
-(** A coherence. *)
-and Coh : sig
-  type t
-
-  val ps : t -> PS.t
-  val ty : t -> Ty.t
-  val src : t -> (t, Tm.t) tm
-  val tgt : t -> (t, Tm.t) tm
-  val check : ps -> (t, Tm.t) ty -> pp_data -> t
-  val check_noninv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
-  val check_inv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
-  val to_string : ?unroll:bool -> t -> string
-  val is_inv : t -> bool
-  val noninv_srctgt : t -> (t, Tm.t) tm * (t, Tm.t) tm * (t, Tm.t) ty
-  val forget : t -> ps * (t, Tm.t) ty * pp_data
-  val func_data : t -> (Var.t * int) list list
-  val is_equal : t -> t -> bool
-  val check_equal : t -> t -> unit
-  val dim : t -> int
-
-  val apply_ps :
-    (ps -> ps) ->
-    ((t, Tm.t) ty -> (t, Tm.t) ty) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t
-
-  val apply :
-    ((t, Tm.t) ctx -> (t, Tm.t) ctx) ->
-    ((t, Tm.t) ty -> (t, Tm.t) ty) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t * (t, Tm.t) sub
-end = struct
-  type cohInv = { ps : PS.t; ty : Ty.t }
-  type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
-  type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
+        try
+          let src_inclusion = PS.source ps in
+          let src = Tm.preimage src src_inclusion in
+          if not (Tm.is_full src) then raise NotAlgebraic
+          else
+            let tgt_inclusion = PS.target ps in
+            let tgt = Tm.preimage tgt tgt_inclusion in
+            if not (Tm.is_full tgt) then raise NotAlgebraic
+            else NonInv ({ ps; src; tgt; total_ty = ty }, name)
+        with NotInImage -> raise NotAlgebraic
+
+    let check ps_unchkd t_unchkd ((name, _, _) as pp_data) =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "checking coherence (%s,%s)"
+             (Printing.ps_to_string ps_unchkd)
+             (Printing.ty_to_string t_unchkd)));
+      match Hashtbl.find_opt tbl (ps_unchkd, t_unchkd) with
+      | Some coh -> coh
+      | None -> (
+          try
+            let cps = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
+            let ps = PS.mk cps in
+            let t = Ty.check cps t_unchkd in
+            let coh = algebraic ps t pp_data in
+            Hashtbl.add tbl (ps_unchkd, t_unchkd) coh;
+            coh
+          with
+          | NotAlgebraic ->
+              Error.not_valid_coherence name
+                (Printf.sprintf "type %s not algebraic in pasting scheme %s"
+                   (Printing.ty_to_string t_unchkd)
+                   (Printing.ctx_to_string (Unchecked.ps_to_ctx ps_unchkd)))
+          | DoubledVar s ->
+              Error.not_valid_coherence name
+                (Printf.sprintf "variable %s appears twice in the context" s))
+
+    let check_noninv ps_unchkd src_unchkd tgt_unchkd name =
+      match Hashtbl.find_opt tbl_noninv (ps_unchkd, src_unchkd, tgt_unchkd) with
+      | Some coh -> coh
+      | None ->
+          let ps = PS.mk (Ctx.check (Unchecked.ps_to_ctx ps_unchkd)) in
+          let src_inclusion = PS.source ps in
+          let tgt_inclusion = PS.target ps in
+          let bdry = PS.bdry ps in
+          let cbdry = PS.to_ctx bdry in
+          let src = Tm.check cbdry src_unchkd in
+          if not (Tm.is_full src) then raise NotAlgebraic
+          else
+            let tgt = Tm.check cbdry tgt_unchkd in
+            if not (Tm.is_full tgt) then raise NotAlgebraic
+            else
+              let total_ty =
+                Ty.morphism
+                  (Tm.apply_sub src src_inclusion)
+                  (Tm.apply_sub tgt tgt_inclusion)
+              in
+              let coh = NonInv ({ ps; src; tgt; total_ty }, name) in
+              Hashtbl.add tbl_noninv (ps_unchkd, src_unchkd, tgt_unchkd) coh;
+              coh
+
+    let check_inv ps_unchkd src_unchkd tgt_unchkd name =
+      match Hashtbl.find_opt tbl_inv (ps_unchkd, src_unchkd, tgt_unchkd) with
+      | Some coh -> coh
+      | None ->
+          let ctx = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
+          let ps = PS.mk ctx in
+          let src = Tm.check ctx src_unchkd in
+          let tgt = Tm.check ctx tgt_unchkd in
+          let ty = Ty.morphism src tgt in
+          if Ty.is_full ty then (
+            let coh = Inv ({ ps; ty }, name) in
+            Hashtbl.add tbl_inv (ps_unchkd, src_unchkd, tgt_unchkd) coh;
+            coh)
+          else raise NotAlgebraic
+
+    let data c =
+      match c with
+      | Inv (d, pp_data) -> (d.ps, d.ty, pp_data)
+      | NonInv (d, pp_data) -> (d.ps, d.total_ty, pp_data)
+
+    let to_string ?(unroll = false) c =
+      let ps, ty, pp_data = data c in
+      if not (unroll || !Settings.unroll_coherences) then
+        Printing.pp_data_to_string pp_data
+      else Printf.sprintf "Coh(%s,%s)" (PS.to_string ps) (Ty.to_string ty)
+
+    let noninv_srctgt c =
+      match c with
+      | Inv (_, _) -> Error.fatal "non-invertible data of an invertible coh"
+      | NonInv (d, _) ->
+          (Tm.forget d.src, Tm.forget d.tgt, Ty.forget (Tm.typ d.src))
+
+    let dim c =
+      let ty =
+        match c with Inv (d, _) -> d.ty | NonInv (d, _) -> d.total_ty
+      in
+      Ty.dim ty
+
+    let func_data = function
+      | Inv (_, (_, _, func)) | NonInv (_, (_, _, func)) -> func
+
+    let forget c =
+      let ps, ty, pp_data = data c in
+      (PS.forget ps, Ty.forget ty, pp_data)
+
+    let is_equal coh1 coh2 =
+      coh1 == coh2
+      ||
+      match (coh1, coh2) with
+      | Inv (d1, _), Inv (d2, _) ->
+          PS.is_equal d1.ps d2.ps && Ty.is_equal d1.ty d2.ty
+      | NonInv (d1, _), NonInv (d2, _) ->
+          PS.is_equal d1.ps d2.ps && Ty.is_equal d1.total_ty d2.total_ty
+      | Inv _, NonInv _ | NonInv _, Inv _ -> false
+
+    let check_equal coh1 coh2 =
+      if not (is_equal coh1 coh2) then
+        raise (NotEqual (to_string coh1, to_string coh2))
+
+    let apply_ps fun_ps fun_ty fun_pp_data coh =
+      let ps, ty, pp = forget coh in
+      let ps = fun_ps ps in
+      let pp_data = fun_pp_data pp in
+      let ty = fun_ty ty in
+      check ps ty pp_data
+
+    let apply fun_ctx fun_ty fun_pp_data coh =
+      let ps, ty, pp = forget coh in
+      let ctx = fun_ctx (Unchecked.ps_to_ctx ps) in
+      let ps = PS.forget (PS.mk (Ctx.check ctx)) in
+      let db_sub = Unchecked.db_level_sub_inv ctx in
+      let pp_data = Display_maps.pp_data_rename (fun_pp_data pp) db_sub in
+      let ty = Unchecked.ty_apply_sub (fun_ty ty) db_sub in
+      (check ps ty pp_data, db_sub)
+  end
 
   module Core = struct
     module Coh = Coh
     module Tm = Tm
   end
 
-  open Syntax.Make (Core)
-
-  let tbl : (ps * ty, Coh.t) Hashtbl.t = Hashtbl.create 7829
-  let tbl_inv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
-  let tbl_noninv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
-
-  exception NotAlgebraic
-
-  let ps = function Inv (data, _) -> data.ps | NonInv (data, _) -> data.ps
-
-  let ty = function
-    | Inv (data, _) -> data.ty
-    | NonInv (data, _) -> data.total_ty
-
-  let src c = Tm.forget (Ty.source (ty c))
-  let tgt c = Tm.forget (Ty.target (ty c))
-  let is_inv = function Inv (_, _) -> true | NonInv (_, _) -> false
-
-  let algebraic ps ty name =
-    if Ty.is_full ty then (
-      Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
-      Inv ({ ps; ty }, name))
-    else
-      let _, src, tgt =
-        try Ty.retrieve_arrow ty with IsObj -> raise NotAlgebraic
-      in
-      try
-        let src_inclusion = PS.source ps in
-        let src = Tm.preimage src src_inclusion in
-        if not (Tm.is_full src) then raise NotAlgebraic
-        else
-          let tgt_inclusion = PS.target ps in
-          let tgt = Tm.preimage tgt tgt_inclusion in
-          if not (Tm.is_full tgt) then raise NotAlgebraic
-          else NonInv ({ ps; src; tgt; total_ty = ty }, name)
-      with NotInImage -> raise NotAlgebraic
-
-  let check ps_unchkd t_unchkd ((name, _, _) as pp_data) =
-    Io.info ~v:5
-      (lazy
-        (Printf.sprintf "checking coherence (%s,%s)"
-           (Printing.ps_to_string ps_unchkd)
-           (Printing.ty_to_string t_unchkd)));
-    match Hashtbl.find_opt tbl (ps_unchkd, t_unchkd) with
-    | Some coh -> coh
-    | None -> (
-        try
-          let cps = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
-          let ps = PS.mk cps in
-          let t = Ty.check cps t_unchkd in
-          let coh = algebraic ps t pp_data in
-          Hashtbl.add tbl (ps_unchkd, t_unchkd) coh;
-          coh
-        with
-        | NotAlgebraic ->
-            Error.not_valid_coherence name
-              (Printf.sprintf "type %s not algebraic in pasting scheme %s"
-                 (Printing.ty_to_string t_unchkd)
-                 (Printing.ctx_to_string (Unchecked.ps_to_ctx ps_unchkd)))
-        | DoubledVar s ->
-            Error.not_valid_coherence name
-              (Printf.sprintf "variable %s appears twice in the context" s))
-
-  let check_noninv ps_unchkd src_unchkd tgt_unchkd name =
-    match Hashtbl.find_opt tbl_noninv (ps_unchkd, src_unchkd, tgt_unchkd) with
-    | Some coh -> coh
-    | None ->
-        let ps = PS.mk (Ctx.check (Unchecked.ps_to_ctx ps_unchkd)) in
-        let src_inclusion = PS.source ps in
-        let tgt_inclusion = PS.target ps in
-        let bdry = PS.bdry ps in
-        let cbdry = PS.to_ctx bdry in
-        let src = Tm.check cbdry src_unchkd in
-        if not (Tm.is_full src) then raise NotAlgebraic
-        else
-          let tgt = Tm.check cbdry tgt_unchkd in
-          if not (Tm.is_full tgt) then raise NotAlgebraic
-          else
-            let total_ty =
-              Ty.morphism
-                (Tm.apply_sub src src_inclusion)
-                (Tm.apply_sub tgt tgt_inclusion)
-            in
-            let coh = NonInv ({ ps; src; tgt; total_ty }, name) in
-            Hashtbl.add tbl_noninv (ps_unchkd, src_unchkd, tgt_unchkd) coh;
-            coh
-
-  let check_inv ps_unchkd src_unchkd tgt_unchkd name =
-    match Hashtbl.find_opt tbl_inv (ps_unchkd, src_unchkd, tgt_unchkd) with
-    | Some coh -> coh
-    | None ->
-        let ctx = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
-        let ps = PS.mk ctx in
-        let src = Tm.check ctx src_unchkd in
-        let tgt = Tm.check ctx tgt_unchkd in
-        let ty = Ty.morphism src tgt in
-        if Ty.is_full ty then (
-          let coh = Inv ({ ps; ty }, name) in
-          Hashtbl.add tbl_inv (ps_unchkd, src_unchkd, tgt_unchkd) coh;
-          coh)
-        else raise NotAlgebraic
-
-  let data c =
-    match c with
-    | Inv (d, pp_data) -> (d.ps, d.ty, pp_data)
-    | NonInv (d, pp_data) -> (d.ps, d.total_ty, pp_data)
-
-  let to_string ?(unroll = false) c =
-    let ps, ty, pp_data = data c in
-    if not (unroll || !Settings.unroll_coherences) then
-      Printing.pp_data_to_string pp_data
-    else Printf.sprintf "Coh(%s,%s)" (PS.to_string ps) (Ty.to_string ty)
-
-  let noninv_srctgt c =
-    match c with
-    | Inv (_, _) -> Error.fatal "non-invertible data of an invertible coh"
-    | NonInv (d, _) ->
-        (Tm.forget d.src, Tm.forget d.tgt, Ty.forget (Tm.typ d.src))
-
-  let dim c =
-    let ty = match c with Inv (d, _) -> d.ty | NonInv (d, _) -> d.total_ty in
-    Ty.dim ty
-
-  let func_data = function
-    | Inv (_, (_, _, func)) | NonInv (_, (_, _, func)) -> func
-
-  let forget c =
-    let ps, ty, pp_data = data c in
-    (PS.forget ps, Ty.forget ty, pp_data)
-
-  let is_equal coh1 coh2 =
-    coh1 == coh2
-    ||
-    match (coh1, coh2) with
-    | Inv (d1, _), Inv (d2, _) ->
-        PS.is_equal d1.ps d2.ps && Ty.is_equal d1.ty d2.ty
-    | NonInv (d1, _), NonInv (d2, _) ->
-        PS.is_equal d1.ps d2.ps && Ty.is_equal d1.total_ty d2.total_ty
-    | Inv _, NonInv _ | NonInv _, Inv _ -> false
-
-  let check_equal coh1 coh2 =
-    if not (is_equal coh1 coh2) then
-      raise (NotEqual (to_string coh1, to_string coh2))
-
-  let apply_ps fun_ps fun_ty fun_pp_data coh =
-    let ps, ty, pp = forget coh in
-    let ps = fun_ps ps in
-    let pp_data = fun_pp_data pp in
-    let ty = fun_ty ty in
-    check ps ty pp_data
-
-  let apply fun_ctx fun_ty fun_pp_data coh =
-    let ps, ty, pp = forget coh in
-    let ctx = fun_ctx (Unchecked.ps_to_ctx ps) in
-    let ps = PS.forget (PS.mk (Ctx.check ctx)) in
-    let db_sub = Unchecked.db_level_sub_inv ctx in
-    let pp_data = Display_maps.pp_data_rename (fun_pp_data pp) db_sub in
-    let ty = Unchecked.ty_apply_sub (fun_ty ty) db_sub in
-    (check ps ty pp_data, db_sub)
+  include Syntax.Make (Core)
+
+  let check check_fn name =
+    let v = 2 in
+    let fname = if !Settings.verbosity >= v then Lazy.force name else "" in
+    Io.info ~v (lazy ("checking " ^ fname));
+    try check_fn () with
+    | NotEqual (s1, s2) ->
+        Error.untypable
+          (if !Settings.verbosity >= v then fname else Lazy.force name)
+          (Printf.sprintf "%s and %s are not equal" s1 s2)
+    | InvalidSubTarget (s, tgt) ->
+        Error.untypable
+          (if !Settings.verbosity >= v then fname else Lazy.force name)
+          (Printf.sprintf "substitution %s does not apply from context %s" s tgt)
+    | Error.UnknownId s ->
+        Error.untypable
+          (if !Settings.verbosity >= v then fname else Lazy.force name)
+          (Printf.sprintf "unknown identifier :%s" s)
+    | MetaVariable ->
+        Error.incomplete_constraints
+          (if !Settings.verbosity >= v then fname else Lazy.force name)
+
+  let check_type ctx a =
+    let ty = lazy ("type: " ^ Printing.ty_to_string a) in
+    check (fun () -> Ty.check ctx a) ty
+
+  let check_term ctx ?ty ?name t =
+    let ty = Option.map (check_type ctx) ty in
+    let tm = lazy ("term: " ^ Printing.tm_to_string t) in
+    check (fun () -> Tm.check ctx ?ty ?name t) tm
+
+  let check_constr ?name ctx constr =
+    let ctx = Ctx.check ctx in
+    let t, ty = constr in
+    let ty = if !Settings.debug then None else Some ty in
+    check_term ctx ?ty ?name t
+
+  let check_coh ps ty pp_data =
+    let c = lazy ("coherence: " ^ Printing.pp_data_to_string pp_data) in
+    check (fun () -> Coh.check ps ty pp_data) c
+
+  let check_sub src s tgt =
+    ignore @@ Sub.check (Ctx.check src) s (Ctx.check tgt)
 end
-
-module Core = struct
-  module Coh = Coh
-  module Tm = Tm
-end
-
-include Syntax.Make (Core)
-
-let check check_fn name =
-  let v = 2 in
-  let fname = if !Settings.verbosity >= v then Lazy.force name else "" in
-  Io.info ~v (lazy ("checking " ^ fname));
-  try check_fn () with
-  | NotEqual (s1, s2) ->
-      Error.untypable
-        (if !Settings.verbosity >= v then fname else Lazy.force name)
-        (Printf.sprintf "%s and %s are not equal" s1 s2)
-  | InvalidSubTarget (s, tgt) ->
-      Error.untypable
-        (if !Settings.verbosity >= v then fname else Lazy.force name)
-        (Printf.sprintf "substitution %s does not apply from context %s" s tgt)
-  | Error.UnknownId s ->
-      Error.untypable
-        (if !Settings.verbosity >= v then fname else Lazy.force name)
-        (Printf.sprintf "unknown identifier :%s" s)
-  | MetaVariable ->
-      Error.incomplete_constraints
-        (if !Settings.verbosity >= v then fname else Lazy.force name)
-
-let check_type ctx a =
-  let ty = lazy ("type: " ^ Printing.ty_to_string a) in
-  check (fun () -> Ty.check ctx a) ty
-
-let check_term ctx ?ty ?name t =
-  let ty = Option.map (check_type ctx) ty in
-  let tm = lazy ("term: " ^ Printing.tm_to_string t) in
-  check (fun () -> Tm.check ctx ?ty ?name t) tm
-
-let check_constr ?name ctx constr =
-  let ctx = Ctx.check ctx in
-  let t, ty = constr in
-  let ty = if !Settings.debug then None else Some ty in
-  check_term ctx ?ty ?name t
-
-let check_coh ps ty pp_data =
-  let c = lazy ("coherence: " ^ Printing.pp_data_to_string pp_data) in
-  check (fun () -> Coh.check ps ty pp_data) c
-
-let check_sub src s tgt = ignore @@ Sub.check (Ctx.check src) s (Ctx.check tgt)
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index 0625bb32..aee6cbc2 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,95 +1,100 @@
 open Common
 
-module rec Coh : sig
-  type t
-
-  val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
-  val is_equal : t -> t -> bool
-  val check_equal : t -> t -> unit
-  val is_inv : t -> bool
-  val to_string : ?unroll:bool -> t -> string
-  val dim : t -> int
-  val src : t -> (Coh.t, Tm.t) tm
-  val tgt : t -> (Coh.t, Tm.t) tm
-  val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
-  val check_noninv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
-  val check_inv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
-
-  val noninv_srctgt :
-    t -> (Coh.t, Tm.t) tm * (Coh.t, Tm.t) tm * (Coh.t, Tm.t) ty
-
-  val func_data : t -> (Var.t * int) list list
-
-  val apply_ps :
-    (ps -> ps) ->
-    ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t
-
-  val apply :
-    ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-    ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t * (Coh.t, Tm.t) sub
+module Make (_ : Theory.S) : sig
+  module rec Coh : sig
+    type t
+
+    val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val is_inv : t -> bool
+    val to_string : ?unroll:bool -> t -> string
+    val dim : t -> int
+    val src : t -> (Coh.t, Tm.t) tm
+    val tgt : t -> (Coh.t, Tm.t) tm
+    val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
+
+    val check_noninv :
+      ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
+
+    val check_inv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
+
+    val noninv_srctgt :
+      t -> (Coh.t, Tm.t) tm * (Coh.t, Tm.t) tm * (Coh.t, Tm.t) ty
+
+    val func_data : t -> (Var.t * int) list list
+
+    val apply_ps :
+      (ps -> ps) ->
+      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) sub
+  end
+
+  and Ty : sig
+    type t
+
+    val forget : t -> (Coh.t, Tm.t) ty
+  end
+
+  and Tm : sig
+    type t
+
+    val typ : t -> Ty.t
+    val ty : t -> (Coh.t, Tm.t) ty
+    val forget : t -> (Coh.t, Tm.t) tm
+    val constr : t -> (Coh.t, Tm.t) constr
+    val bdry : t -> t * t
+    val ctx : t -> (Coh.t, Tm.t) ctx
+    val name : t -> string option
+    val full_name : t -> string option
+    val func_data : t -> (Var.t * int) list list option
+    val of_coh : Coh.t -> t
+    val develop : t -> (Coh.t, Tm.t) tm
+    val pp_data : t -> pp_data option
+    val to_string : t -> string
+    val is_equal : t -> t -> bool
+
+    val apply :
+      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+      ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) sub
+  end
+
+  module Core : sig
+    module Coh = Coh
+    module Tm = Tm
+  end
+
+  include module type of Syntax.Make (Core)
+
+  module Ctx : sig
+    type t
+
+    val check : ctx -> t
+  end
+
+  module PS : sig
+    exception Invalid
+
+    type t
+
+    val mk : Ctx.t -> t
+    val forget : t -> ps
+  end
+
+  val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
+  val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
+  val check_coh : ps -> ty -> pp_data -> Coh.t
+  val check_sub : ctx -> sub -> ctx -> unit
 end
-
-and Ty : sig
-  type t
-
-  val forget : t -> (Coh.t, Tm.t) ty
-end
-
-and Tm : sig
-  type t
-
-  val typ : t -> Ty.t
-  val ty : t -> (Coh.t, Tm.t) ty
-  val forget : t -> (Coh.t, Tm.t) tm
-  val constr : t -> (Coh.t, Tm.t) constr
-  val bdry : t -> t * t
-  val ctx : t -> (Coh.t, Tm.t) ctx
-  val name : t -> string option
-  val full_name : t -> string option
-  val func_data : t -> (Var.t * int) list list option
-  val of_coh : Coh.t -> t
-  val develop : t -> (Coh.t, Tm.t) tm
-  val pp_data : t -> pp_data option
-  val to_string : t -> string
-  val is_equal : t -> t -> bool
-
-  val apply :
-    ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-    ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t * (Coh.t, Tm.t) sub
-end
-
-module Core : sig
-  module Coh = Coh
-  module Tm = Tm
-end
-
-include module type of Syntax.Make (Core)
-
-module Ctx : sig
-  type t
-
-  val check : ctx -> t
-end
-
-module PS : sig
-  exception Invalid
-
-  type t
-
-  val mk : Ctx.t -> t
-  val forget : t -> ps
-end
-
-val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
-val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
-val check_coh : ps -> ty -> pp_data -> Coh.t
-val check_sub : ctx -> sub -> ctx -> unit
diff --git a/lib/internals/theory.ml b/lib/internals/theory.ml
new file mode 100644
index 00000000..9e792e04
--- /dev/null
+++ b/lib/internals/theory.ml
@@ -0,0 +1,13 @@
+open Common
+
+module type S = sig
+  val theory : theory
+  val environment_created : bool ref
+end
+
+let make theory =
+  let module Theory = struct
+    let theory = theory
+    let environment_created = ref false
+  end in
+  (module Theory : S)
diff --git a/lib/internals/theory.mli b/lib/internals/theory.mli
new file mode 100644
index 00000000..1c551251
--- /dev/null
+++ b/lib/internals/theory.mli
@@ -0,0 +1,8 @@
+open Common
+
+module type S = sig
+  val theory : theory
+  val environment_created : bool ref
+end
+
+val make : theory -> (module S)
diff --git a/lib/lib/command.ml b/lib/lib/command.ml
index 37f5a31b..6111992f 100644
--- a/lib/lib/command.ml
+++ b/lib/lib/command.ml
@@ -1,5 +1,4 @@
 open Common
-open Kernel
 open Raw_types
 
 exception UnknownOption of string
@@ -18,44 +17,7 @@ type cmd =
   | Benchmark_builtin of builtin
 
 type prog = cmd list
-
-let postprocess_fn : (ctx -> tm -> ctx * tm) ref = ref (fun c e -> (c, e))
-
-let exec_coh v ps ty =
-  let ps, ty = Elaborate.ty_in_ps ps ty in
-  Environment.add_coh v ps ty
-
-let exec_decl v l e t =
-  let c, e = Elaborate.tm l e in
-  let c, e = if !Settings.postprocess then !postprocess_fn c e else (c, e) in
-  match t with
-  | None -> Environment.add_let v c e
-  | Some ty ->
-      let _, ty = Elaborate.ty l ty in
-      Environment.add_let v c ~ty e
-
-let exec_decl_builtin v b =
-  let value = Environment.builtin_to_value b in
-  Environment.add_value v value
-
-let check l e t =
-  let c, e = Elaborate.tm l e in
-  let ty =
-    match t with
-    | None -> None
-    | Some ty ->
-        let _, ty = Elaborate.ty l ty in
-        Some ty
-  in
-  let c = Kernel.Ctx.check c in
-  let tm = Kernel.check_term c ?ty e in
-  let ty = Kernel.Tm.ty tm in
-  (e, ty)
-
-let exec_check_builtin b =
-  let e = Environment.builtin_to_value b in
-  let ty = Environment.value_ty e in
-  (e, ty)
+type next = Abort | KeepGoing | Interactive | ChangeTheory of theory
 
 let exec_set o v =
   let parse_bool v =
@@ -71,89 +33,33 @@ let exec_set o v =
   let parse_int v =
     match int_of_string_opt v with Some s -> s | None -> raise (NotAnInt v)
   in
-  match o with
-  | _ when String.equal o "explicit_substitutions" ->
-      let v = parse_bool v in
-      Settings.explicit_substitutions := v
-  | _ when String.equal o "print_explicit_substitutions" ->
-      let v = parse_bool v in
-      Settings.print_explicit_substitutions := v
-  | _ when String.equal o "postprocess" ->
-      let v = parse_bool v in
-      Settings.postprocess := v
-  | _ when String.equal o "unroll_coherences" ->
-      let v = parse_bool v in
-      Settings.unroll_coherences := v
-  | _ when String.equal o "implicit_suspension" ->
-      let v = parse_bool v in
-      Settings.implicit_suspension := v
-  | _ when String.equal o "verbosity" ->
-      let v = parse_int v in
-      Settings.verbosity := v
-  | _ -> raise (UnknownOption o)
-
-let exec_cmd cmd =
-  match cmd with
-  | Coh (x, ps, e) ->
-      Io.command "coh %s = %s" (Var.to_string x) (Raw.string_of_ty e);
-      let coh = exec_coh x ps e in
-      Io.info
-        (lazy (Printf.sprintf "successfully defined %s" (Coh.to_string coh)))
-  | Check (l, e, t) ->
-      Io.command "check %s" (Raw.string_of_tm e);
-      let e, ty = check l e t in
-      Io.info
-        (lazy
-          (Printf.sprintf "valid term %s of type %s" (Printing.tm_to_string e)
-             (Printing.ty_to_string ty)))
-  | Decl (v, l, e, t) ->
-      Io.command "let %s = %s" (Var.to_string v) (Raw.string_of_tm e);
-      let tm, ty = exec_decl v l e t in
-      Io.info
-        (lazy
-          (Printf.sprintf "successfully defined term %s of type %s"
-             (Printing.tm_to_string tm) (Printing.ty_to_string ty)))
-  | Set (o, v) -> (
-      try exec_set o v with
-      | UnknownOption o -> Error.unknown_option o
-      | NotAnInt v -> Error.wrong_option_argument ~expected:"int" o v
-      | NotABoolean v -> Error.wrong_option_argument ~expected:"boolean" o v)
-  | Check_builtin b ->
-      Io.command "check %s" (Raw.string_of_builtin b);
-      let e, ty = exec_check_builtin b in
-      Io.info
-        (lazy
-          (Printf.sprintf "valid term %s of type %s"
-             (Environment.value_to_string e)
-             (Printing.ty_to_string ty)))
-  | Decl_builtin (v, b) ->
-      Io.command "let %s = %s" (Var.to_string v) (Raw.string_of_builtin b);
-      let e, ty = exec_decl_builtin v b in
-      Io.info
-        (lazy
-          (Printf.sprintf "successfully defined term %s of type %s"
-             (Environment.value_to_string e)
-             (Printing.ty_to_string ty)))
-  | Benchmark (l, e) ->
-      let e, _ = check l e None in
-      Io.info
-        (lazy
-          (Printf.sprintf "term computes to:\n %s"
-             (Printing.print_kolmogorov e)))
-  | Benchmark_builtin b ->
-      let e, _ = exec_check_builtin b in
-      let e =
-        match e with
-        | Environment.Coh _ ->
-            Error.fatal "bechmarking a builtin resolving to a coherence"
-        | Environment.Tm e -> Tm.develop e
-      in
-      Io.info
-        (lazy
-          (Printf.sprintf "term computes to:\n %s"
-             (Printing.print_kolmogorov e)))
+  let _ =
+    match o with
+    | _ when String.equal o "explicit_substitutions" ->
+        let v = parse_bool v in
+        Settings.explicit_substitutions := v
+    | _ when String.equal o "print_explicit_substitutions" ->
+        let v = parse_bool v in
+        Settings.print_explicit_substitutions := v
+    | _ when String.equal o "postprocess" ->
+        let v = parse_bool v in
+        Settings.postprocess := v
+    | _ when String.equal o "unroll_coherences" ->
+        let v = parse_bool v in
+        Settings.unroll_coherences := v
+    | _ when String.equal o "implicit_suspension" ->
+        let v = parse_bool v in
+        Settings.implicit_suspension := v
+    | _ when String.equal o "verbosity" ->
+        let v = parse_int v in
+        Settings.verbosity := v
+    | _ -> raise (UnknownOption o)
+  in
+  KeepGoing
 
-type next = Abort | KeepGoing | Interactive
+let _exec_set_theory d =
+  let t = { strictness = Weak; invertibility = d; postulates = [] } in
+  ChangeTheory t
 
 let show_menu () =
   Io.eprintf
@@ -173,29 +79,165 @@ let show_menu () =
   in
   decision ()
 
-let initialise () = Cubical_composite.init ()
-
-let exec ~loop_fn prog =
-  initialise ();
-  let rec aux = function
-    | [] -> ()
-    | t :: l -> (
-        let next =
-          try
-            exec_cmd t;
-            KeepGoing
-          with
-          | Error.InvalidEntry ->
-              if !Settings.keep_going then KeepGoing
-              else if !Settings.debug then show_menu ()
-              else (
-                Io.printf "Aborting...";
-                Abort)
-          | Error.OptionsError -> KeepGoing
-        in
-        match next with
-        | KeepGoing -> aux l
-        | Abort -> exit 1
-        | Interactive -> loop_fn ())
-  in
-  aux prog
+module rec Toplevel : sig
+  val exec : ?theory:theory -> loop_fn:(unit -> unit) -> prog -> unit
+end = struct
+  let exec ?(theory = vanilla_theory) ~loop_fn prog =
+    let module Theory = (val Theory.make theory : Theory.S) in
+    let module Command = Make (Theory) in
+    Command.exec ~loop_fn prog
+end
+
+and Make : functor (CurrentTheory : Theory.S) -> sig
+  val exec : loop_fn:(unit -> unit) -> prog -> unit
+end =
+functor
+  (CurrentTheory : Theory.S)
+  ->
+  struct
+    module CurrentEnvironment = Environments.Make (CurrentTheory)
+    module Elaborate = Elaborate.Make (CurrentEnvironment)
+    open CurrentEnvironment
+
+    let postprocess_fn : (ctx -> tm -> ctx * tm) ref = ref (fun c e -> (c, e))
+
+    let exec_coh v ps ty =
+      let ps, ty = Elaborate.ty_in_ps ps ty in
+      Environment.add_coh v ps ty
+
+    let exec_decl v l e t =
+      let c, e = Elaborate.tm l e in
+      let c, e =
+        if !Settings.postprocess then !postprocess_fn c e else (c, e)
+      in
+      match t with
+      | None -> Environment.add_let v c e
+      | Some ty ->
+          let _, ty = Elaborate.ty l ty in
+          Environment.add_let v c ~ty e
+
+    let exec_decl_builtin v b =
+      let value = Environment.builtin_to_value b in
+      Environment.add_value v value
+
+    let check l e t =
+      let c, e = Elaborate.tm l e in
+      let ty =
+        match t with
+        | None -> None
+        | Some ty ->
+            let _, ty = Elaborate.ty l ty in
+            Some ty
+      in
+      let c = Ctx.check c in
+      let tm = check_term c ?ty e in
+      let ty = Tm.ty tm in
+      (e, ty)
+
+    let exec_check_builtin b =
+      let e = Environment.builtin_to_value b in
+      let ty = Environment.value_ty e in
+      (e, ty)
+
+    let exec_cmd cmd =
+      match cmd with
+      | Coh (x, ps, e) ->
+          Io.command "coh %s = %s" (Var.to_string x) (Raw.string_of_ty e);
+          let coh = exec_coh x ps e in
+          Io.info
+            (lazy
+              (Printf.sprintf "successfully defined %s" (Coh.to_string coh)));
+          KeepGoing
+      | Check (l, e, t) ->
+          Io.command "check %s" (Raw.string_of_tm e);
+          let e, ty = check l e t in
+          Io.info
+            (lazy
+              (Printf.sprintf "valid term %s of type %s"
+                 (Printing.tm_to_string e) (Printing.ty_to_string ty)));
+          KeepGoing
+      | Decl (v, l, e, t) ->
+          Io.command "let %s = %s" (Var.to_string v) (Raw.string_of_tm e);
+          let tm, ty = exec_decl v l e t in
+          Io.info
+            (lazy
+              (Printf.sprintf "successfully defined term %s of type %s"
+                 (Printing.tm_to_string tm) (Printing.ty_to_string ty)));
+          KeepGoing
+      | Set (o, v) -> (
+          try exec_set o v with
+          | UnknownOption o -> Error.unknown_option o
+          | NotAnInt v -> Error.wrong_option_argument ~expected:"int" o v
+          | NotABoolean v -> Error.wrong_option_argument ~expected:"boolean" o v
+          )
+      | Check_builtin b ->
+          Io.command "check %s" (Raw.string_of_builtin b);
+          let e, ty = exec_check_builtin b in
+          Io.info
+            (lazy
+              (Printf.sprintf "valid term %s of type %s"
+                 (Environment.value_to_string e)
+                 (Printing.ty_to_string ty)));
+          KeepGoing
+      | Decl_builtin (v, b) ->
+          Io.command "let %s = %s" (Var.to_string v) (Raw.string_of_builtin b);
+          let e, ty = exec_decl_builtin v b in
+          Io.info
+            (lazy
+              (Printf.sprintf "successfully defined term %s of type %s"
+                 (Environment.value_to_string e)
+                 (Printing.ty_to_string ty)));
+          KeepGoing
+      | Benchmark (l, e) ->
+          let e, _ = check l e None in
+          Io.info
+            (lazy
+              (Printf.sprintf "term computes to:\n %s"
+                 (Printing.print_kolmogorov e)));
+          KeepGoing
+      | Benchmark_builtin b ->
+          let e, _ = exec_check_builtin b in
+          let e =
+            match e with
+            | Environment.Coh _ ->
+                Error.fatal "bechmarking a builtin resolving to a coherence"
+            | Environment.Tm e -> Tm.develop e
+          in
+          Io.info
+            (lazy
+              (Printf.sprintf "term computes to:\n %s"
+                 (Printing.print_kolmogorov e)));
+          KeepGoing
+
+    let initialise () = Cubical_composite.init ()
+
+    let exec ~loop_fn prog =
+      initialise ();
+      let rec aux = function
+        | [] ->
+            Environments.store_environment
+              (module CurrentEnvironment : Environments.S)
+        | t :: l -> (
+            let next =
+              try exec_cmd t with
+              | Error.InvalidEntry ->
+                  if !Settings.keep_going then KeepGoing
+                  else if !Settings.debug then show_menu ()
+                  else (
+                    Io.printf "Aborting...";
+                    Abort)
+              | Error.OptionsError -> KeepGoing
+            in
+            match next with
+            | KeepGoing -> aux l
+            | Abort -> exit 1
+            | Interactive -> loop_fn ()
+            | ChangeTheory t ->
+                Environments.store_environment
+                  (module CurrentEnvironment : Environments.S);
+                Toplevel.exec ~theory:t ~loop_fn l)
+      in
+      aux prog
+  end
+
+let exec = Toplevel.exec
diff --git a/lib/lib/command.mli b/lib/lib/command.mli
index 13cc143f..559bc70d 100644
--- a/lib/lib/command.mli
+++ b/lib/lib/command.mli
@@ -1,5 +1,4 @@
 open Common
-open Kernel
 open Raw_types
 
 type cmd =
@@ -14,5 +13,4 @@ type cmd =
 
 type prog = cmd list
 
-val postprocess_fn : (ctx -> tm -> ctx * tm) ref
-val exec : loop_fn:(unit -> unit) -> prog -> unit
+val exec : ?theory:theory -> loop_fn:(unit -> unit) -> prog -> unit
diff --git a/lib/lib/common.ml b/lib/lib/common.ml
index f9920dca..1149c689 100644
--- a/lib/lib/common.ml
+++ b/lib/lib/common.ml
@@ -72,3 +72,17 @@ let rec take n l =
   match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
 
 type op_data = int list
+
+(* For managing theories *)
+type strictness = Weak | Idempotent | Units | UAssociators
+type invertibility = int option
+type postulates = TerminalObject
+
+type theory = {
+  strictness : strictness;
+  invertibility : invertibility;
+  postulates : postulates list;
+}
+
+let vanilla_theory =
+  { strictness = Weak; invertibility = None; postulates = [] }
diff --git a/lib/lib/common.mli b/lib/lib/common.mli
index 16f55de8..d2b0d466 100644
--- a/lib/lib/common.mli
+++ b/lib/lib/common.mli
@@ -43,3 +43,16 @@ type pp_data = string * int * (Var.t * int) list list
 val take : int -> 'a list -> 'a list
 
 type op_data = int list
+
+(* For managing theories *)
+type strictness = Weak | Idempotent | Units | UAssociators
+type invertibility = int option
+type postulates = TerminalObject
+
+type theory = {
+  strictness : strictness;
+  invertibility : invertibility;
+  postulates : postulates list;
+}
+
+val vanilla_theory : theory
diff --git a/lib/lib/environment.ml b/lib/lib/environment.ml
deleted file mode 100644
index 39ef59dc..00000000
--- a/lib/lib/environment.ml
+++ /dev/null
@@ -1,83 +0,0 @@
-open Common
-open Raw_types
-open Kernel
-
-type value = Coh of Coh.t | Tm of Tm.t
-
-let builtin_to_value b =
-  match b with
-  | Comp -> Coh (Builtin.comp_n 1)
-  | Id -> Coh (Builtin.id ())
-  | Conecomp (n, k, m) -> Tm (Cones.compose n m k)
-  | Cylcomp (n, k, m) -> Tm (Cylinders.compose n m k)
-  | Cylstack n -> Tm (Cylinders.stacking n)
-  | Eh_half (n, k, l) -> Tm (Eh.eh n k l)
-  | Eh_full (n, k, l) -> Tm (Eh.full_eh n k l)
-
-let value_ty v =
-  match v with
-  | Coh c ->
-      let _, ty, _ = Coh.forget c in
-      ty
-  | Tm t -> Tm.ty t
-
-let value_ctx v =
-  match v with
-  | Coh c ->
-      let ps, _, _ = Coh.forget c in
-      Unchecked.ps_to_ctx ps
-  | Tm t -> Tm.ctx t
-
-let value_to_string v =
-  match v with Coh c -> Coh.to_string c | Tm t -> Tm.to_string t
-
-type v = { value : value; dim_input : int; dim_output : int }
-type t = (Var.t, v) Hashtbl.t
-
-let env : t = Hashtbl.create 70
-let reset () = Hashtbl.clear env
-
-let add_let v c ?ty t =
-  try
-    let pp_data = (Var.to_string v, 0, []) in
-    let kc = Kernel.Ctx.check c in
-    let tm = Kernel.check_term kc ?ty ~name:pp_data t in
-    let ty = Kernel.(Ty.forget (Tm.typ tm)) in
-    let dim_input = Unchecked.dim_ctx c in
-    let dim_output = Unchecked.dim_ty ty in
-    Io.info ~v:4
-      (lazy
-        (Printf.sprintf "term %s of type %s added to environment"
-           (Printing.tm_to_string t) (Printing.ty_to_string ty)));
-    Hashtbl.add env v { value = Tm tm; dim_input; dim_output };
-    (t, ty)
-  with DoubledVar x -> Error.doubled_var (Printing.ctx_to_string c) x
-
-let add_coh v ps ty =
-  let coh = check_coh ps ty (Var.to_string v, 0, []) in
-  let dim_input = Unchecked.dim_ps ps in
-  let dim_output = Unchecked.dim_ty ty in
-  Io.info ~v:4
-    (lazy
-      (Printf.sprintf "coherence %s added to environment" (Var.to_string v)));
-  Hashtbl.add env v { value = Coh coh; dim_input; dim_output };
-  coh
-
-let find v =
-  try Hashtbl.find env v
-  with Not_found -> raise (Error.UnknownId (Var.to_string v))
-
-let add_value v value =
-  let ty = value_ty value in
-  let dim_input = Unchecked.dim_ctx (value_ctx value) in
-  let dim_output = Unchecked.dim_ty ty in
-  Io.info ~v:4
-    (lazy
-      (Printf.sprintf "term %s of type %s added to environment"
-         (value_to_string value) (Printing.ty_to_string ty)));
-  Hashtbl.add env v { value; dim_input; dim_output };
-  (value, ty)
-
-let val_var v = (find v).value
-let dim_output v = (find v).dim_output
-let dim_input v = (find v).dim_input
diff --git a/lib/lib/environment.mli b/lib/lib/environment.mli
deleted file mode 100644
index fe301508..00000000
--- a/lib/lib/environment.mli
+++ /dev/null
@@ -1,16 +0,0 @@
-open Common
-open Kernel
-
-type value = Coh of Coh.t | Tm of Tm.t
-type t
-
-val builtin_to_value : Raw_types.builtin -> value
-val value_ty : value -> ty
-val value_to_string : value -> string
-val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
-val add_value : Var.t -> value -> value * ty
-val add_coh : Var.t -> ps -> ty -> Coh.t
-val val_var : Var.t -> value
-val dim_output : Var.t -> int
-val dim_input : Var.t -> int
-val reset : unit -> unit
diff --git a/lib/lib/environments.ml b/lib/lib/environments.ml
new file mode 100644
index 00000000..fa147817
--- /dev/null
+++ b/lib/lib/environments.ml
@@ -0,0 +1,169 @@
+open Common
+open Raw_types
+
+module type S = sig
+  module CurrentTheory : Theory.S
+  include module type of Kernel.Make (CurrentTheory)
+
+  module Environment : sig
+    type value = Coh of Coh.t | Tm of Tm.t
+    type t
+
+    val builtin_to_value : Raw_types.builtin -> value
+    val value_ty : value -> ty
+    val value_to_string : value -> string
+    val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
+    val add_value : Var.t -> value -> value * ty
+    val add_coh : Var.t -> ps -> ty -> Coh.t
+    val val_var : Var.t -> value
+    val dim_output : Var.t -> int
+    val dim_input : Var.t -> int
+    val forall : (Var.t -> unit) -> unit
+  end
+
+  module Suspension : module type of Suspension.Make (CurrentTheory)
+
+  module Functorialisation :
+      module type of Functorialisation.Make (CurrentTheory)
+
+  module Opposite : module type of Opposite.Make (CurrentTheory)
+  module Inverse : module type of Inverse.Make (CurrentTheory)
+  module Builtin : module type of Builtin.Make (CurrentTheory)
+  module Cones : module type of Cones.Make (CurrentTheory)
+  module Cylinders : module type of Cylinders.Make (CurrentTheory)
+  module Eh : module type of Eh.Make (CurrentTheory)
+
+  module Cubical_composite :
+      module type of Cubical_composite.Make (CurrentTheory)
+end
+
+let known_environments : (Var.t, (module S) list) Hashtbl.t = Hashtbl.create 77
+
+let update_known_environments (v : Var.t) env =
+  let module Env = (val env : S) in
+  let list = Hashtbl.find_opt known_environments v in
+  match list with
+  | None -> Hashtbl.add known_environments v [ env ]
+  | Some list ->
+      let rec replace list =
+        match list with
+        | [] -> [ env ]
+        | known_env :: list ->
+            let module KnownEnv = (val known_env : S) in
+            if KnownEnv.CurrentTheory.theory == Env.CurrentTheory.theory then
+              env :: list
+            else known_env :: replace list
+      in
+      Hashtbl.replace known_environments v (replace list)
+
+let store_environment environment =
+  Io.debug "updating the known environments";
+  let open (val environment : S) in
+  Environment.forall (fun v -> update_known_environments v environment)
+
+let find_environment v =
+  Io.debug "trying to find the variable %s" (Var.to_string v);
+  let res = Hashtbl.find known_environments v in
+  Io.debug "found environment";
+  res
+
+module Make (CurrentTheory : Theory.S) = struct
+  module CurrentTheory = CurrentTheory
+  include Kernel.Make (CurrentTheory)
+  module Suspension = Suspension.Make (CurrentTheory)
+  module Functorialisation = Functorialisation.Make (CurrentTheory)
+  module Opposite = Opposite.Make (CurrentTheory)
+  module Inverse = Inverse.Make (CurrentTheory)
+  module Builtin = Builtin.Make (CurrentTheory)
+  module Cones = Cones.Make (CurrentTheory)
+  module Cylinders = Cylinders.Make (CurrentTheory)
+  module Eh = Eh.Make (CurrentTheory)
+  module Cubical_composite = Cubical_composite.Make (CurrentTheory)
+
+  let () =
+    if !CurrentTheory.environment_created then
+      Error.fatal "Environment already created for the theory"
+    else CurrentTheory.environment_created := true
+
+  module Environment = struct
+    type value = Coh of Coh.t | Tm of Tm.t
+
+    let builtin_to_value b =
+      match b with
+      | Comp -> Coh (Builtin.comp_n 1)
+      | Id -> Coh (Builtin.id ())
+      | Conecomp (n, k, m) -> Tm (Cones.compose n m k)
+      | Cylcomp (n, k, m) -> Tm (Cylinders.compose n m k)
+      | Cylstack n -> Tm (Cylinders.stacking n)
+      | Eh_half (n, k, l) -> Tm (Eh.eh n k l)
+      | Eh_full (n, k, l) -> Tm (Eh.full_eh n k l)
+
+    let value_ty v =
+      match v with
+      | Coh c ->
+          let _, ty, _ = Coh.forget c in
+          ty
+      | Tm t -> Tm.ty t
+
+    let value_ctx v =
+      match v with
+      | Coh c ->
+          let ps, _, _ = Coh.forget c in
+          Unchecked.ps_to_ctx ps
+      | Tm t -> Tm.ctx t
+
+    let value_to_string v =
+      match v with Coh c -> Coh.to_string c | Tm t -> Tm.to_string t
+
+    type v = { value : value; dim_input : int; dim_output : int }
+    type t = (Var.t, v) Hashtbl.t
+
+    let env : t = Hashtbl.create 70
+
+    let add_let v c ?ty t =
+      try
+        let pp_data = (Var.to_string v, 0, []) in
+        let kc = Ctx.check c in
+        let tm = check_term kc ?ty ~name:pp_data t in
+        let ty = Ty.forget (Tm.typ tm) in
+        let dim_input = Unchecked.dim_ctx c in
+        let dim_output = Unchecked.dim_ty ty in
+        Io.info ~v:4
+          (lazy
+            (Printf.sprintf "term %s of type %s added to environment"
+               (Printing.tm_to_string t) (Printing.ty_to_string ty)));
+        Hashtbl.add env v { value = Tm tm; dim_input; dim_output };
+        (t, ty)
+      with DoubledVar x -> Error.doubled_var (Printing.ctx_to_string c) x
+
+    let add_coh v ps ty =
+      let coh = check_coh ps ty (Var.to_string v, 0, []) in
+      let dim_input = Unchecked.dim_ps ps in
+      let dim_output = Unchecked.dim_ty ty in
+      Io.info ~v:4
+        (lazy
+          (Printf.sprintf "coherence %s added to environment" (Var.to_string v)));
+      Hashtbl.add env v { value = Coh coh; dim_input; dim_output };
+      coh
+
+    let find v =
+      try Hashtbl.find env v
+      with Not_found -> raise (Error.UnknownId (Var.to_string v))
+
+    let add_value v value =
+      let ty = value_ty value in
+      let dim_input = Unchecked.dim_ctx (value_ctx value) in
+      let dim_output = Unchecked.dim_ty ty in
+      Io.info ~v:4
+        (lazy
+          (Printf.sprintf "term %s of type %s added to environment"
+             (value_to_string value) (Printing.ty_to_string ty)));
+      Hashtbl.add env v { value; dim_input; dim_output };
+      (value, ty)
+
+    let val_var v = (find v).value
+    let dim_output v = (find v).dim_output
+    let dim_input v = (find v).dim_input
+    let forall f = Hashtbl.iter (fun x _ -> f x) env
+  end
+end
diff --git a/lib/lib/environments.mli b/lib/lib/environments.mli
new file mode 100644
index 00000000..d912bbdb
--- /dev/null
+++ b/lib/lib/environments.mli
@@ -0,0 +1,42 @@
+open Common
+
+module type S = sig
+  module CurrentTheory : Theory.S
+  include module type of Kernel.Make (CurrentTheory)
+
+  module Environment : sig
+    type value = Coh of Coh.t | Tm of Tm.t
+    type t
+
+    val builtin_to_value : Raw_types.builtin -> value
+    val value_ty : value -> ty
+    val value_to_string : value -> string
+    val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
+    val add_value : Var.t -> value -> value * ty
+    val add_coh : Var.t -> ps -> ty -> Coh.t
+    val val_var : Var.t -> value
+    val dim_output : Var.t -> int
+    val dim_input : Var.t -> int
+    val forall : (Var.t -> unit) -> unit
+  end
+
+  module Suspension : module type of Suspension.Make (CurrentTheory)
+
+  module Functorialisation :
+      module type of Functorialisation.Make (CurrentTheory)
+
+  module Opposite : module type of Opposite.Make (CurrentTheory)
+  module Inverse : module type of Inverse.Make (CurrentTheory)
+  module Builtin : module type of Builtin.Make (CurrentTheory)
+  module Cones : module type of Cones.Make (CurrentTheory)
+  module Cylinders : module type of Cylinders.Make (CurrentTheory)
+  module Eh : module type of Eh.Make (CurrentTheory)
+
+  module Cubical_composite :
+      module type of Cubical_composite.Make (CurrentTheory)
+end
+
+val store_environment : (module S) -> unit
+val find_environment : Var.t -> (module S) list
+
+module Make (_ : Theory.S) : S
diff --git a/lib/lib/meta.mli b/lib/lib/meta.mli
index 8d4f7cd6..9f73b8da 100644
--- a/lib/lib/meta.mli
+++ b/lib/lib/meta.mli
@@ -1,4 +1,4 @@
-open Kernel
+open Common
 
-val new_ty : unit -> ty
-val new_tm : unit -> tm * (int * ty)
+val new_ty : unit -> ('a, 'b) ty
+val new_tm : unit -> ('a, 'b) tm * (int * ('a, 'b) ty)
diff --git a/lib/lib/raw.ml b/lib/lib/raw.ml
index b2dfa1dc..54daa514 100644
--- a/lib/lib/raw.ml
+++ b/lib/lib/raw.ml
@@ -8,8 +8,8 @@ let string_of_builtin = function
   | Conecomp (n, k, m) -> Printf.sprintf "conecomp(%d,%d,%d)" n k m
   | Cylcomp (n, k, m) -> Printf.sprintf "cylcomp(%d,%d,%d)" n k m
   | Cylstack n -> Printf.sprintf "cylstack(%d)" n
-  | Eh_half (n , k , l) -> Printf.sprintf "eh^%d_(%d,%d)" n k l
-  | Eh_full (n , k , l) -> Printf.sprintf "EH^%d_(%d,%d)" n k l
+  | Eh_half (n, k, l) -> Printf.sprintf "eh^%d_(%d,%d)" n k l
+  | Eh_full (n, k, l) -> Printf.sprintf "EH^%d_(%d,%d)" n k l
 
 let rec string_of_ty e =
   match e with
@@ -52,122 +52,126 @@ and string_of_functed_tm t n =
   if n <= 0 then Printf.sprintf "%s" (string_of_tm t)
   else Printf.sprintf "[%s]" (string_of_functed_tm t (n - 1))
 
-(** remove the let in in a term *)
-let rec replace_tm l e =
-  match e with
-  | VarR a -> ( try replace_tm l (List.assoc a l) with Not_found -> VarR a)
-  | Sub (e, s, susp, b) -> Sub (replace_tm l e, replace_sub l s, susp, b)
-  | BuiltinR _ -> e
-  | Op (op_data, t) -> Op (op_data, replace_tm l t)
-  | Inverse t -> Inverse (replace_tm l t)
-  | Unit t -> Unit (replace_tm l t)
-  | Letin_tm (v, t, tm) -> replace_tm ((v, t) :: l) tm
-  | Meta -> Meta
-
-and replace_sub l s =
-  match s with
-  | [] -> []
-  | (t, f) :: s -> (replace_tm l t, f) :: replace_sub l s
-
-and replace_ty l t =
-  match t with
-  | ObjR -> t
-  | ArrR (u, v) -> ArrR (replace_tm l u, replace_tm l v)
-  | Letin_ty (v, t, ty) -> replace_ty ((v, t) :: l) ty
-
-let remove_let_tm e = replace_tm [] e
-let remove_let_ty e = replace_ty [] e
-
-let rec var_in_ty x ty =
-  match ty with
-  | ObjR -> false
-  | ArrR (u, v) -> var_in_tm x u || var_in_tm x v
-  | Letin_ty _ -> Error.fatal "letin_ty constructors cannot appear here"
-
-and var_in_tm x tm =
-  match tm with
-  | VarR v -> x = v
-  | Sub (_, s, _, _) -> List.exists (fun (t, _) -> var_in_tm x t) s
-  | BuiltinR _ -> false
-  | Inverse t -> var_in_tm x t
-  | Unit t -> var_in_tm x t
-  | Meta -> false
-  | Op (_, t) -> var_in_tm x t
-  | Letin_tm _ -> Error.fatal "letin_tm constructors cannot appear here"
-
-let rec dim_ty ctx = function
-  | ObjR -> 0
-  | ArrR (u, _) -> 1 + dim_tm ctx u
-  | Letin_ty _ -> Error.fatal "letin_ty constructors cannot appear here"
-
-and dim_tm ctx = function
-  | VarR v -> (
-      try dim_ty ctx (List.assoc v ctx)
-      with Not_found -> Error.unknown_id (Var.to_string v))
-  | Sub (tmR, s, i, _) ->
-      let func = List.fold_left (fun i (_, j) -> max i j) 0 s in
-      let d =
-        match tmR with
-        | VarR v -> Environment.dim_output v
-        | BuiltinR b -> dim_builtin b
-        | _ -> Error.fatal "ill-formed term"
-      in
-      let susp = match i with None -> 0 | Some i -> i in
-      d + func + susp
-  | BuiltinR b -> dim_builtin b
-  | Meta -> 0
-  | Op (_, tm) -> dim_tm ctx tm
-  | Inverse t -> dim_tm ctx t
-  | Unit t -> dim_tm ctx t + 1
-  | Letin_tm _ -> Error.fatal "letin_tm constructors cannot appear here"
-
-and dim_builtin = function
-  | Comp -> 1
-  | Id -> 1
-  | Conecomp (n, _, m) | Cylcomp (n, _, m) -> max n m
-  | Cylstack n -> n
-  | Eh_half (n, _, _) | Eh_full (n, _, _) -> n + 1
-
-let rec dim_sub ctx = function
-  | [] -> (0, 0)
-  | (t, f) :: s ->
-      let d1, f1 = dim_sub ctx s in
-      let d2 = dim_tm ctx t in
-      (max d1 d2, max f f1)
-
-let rec infer_susp_tm ctx = function
-  | VarR v -> VarR v
-  | Sub (tmR, s, i, b) -> (
-      let s = infer_susp_sub ctx s in
-      match i with
-      | None ->
-          let inp =
-            match tmR with
-            | VarR v -> Environment.dim_input v
-            | BuiltinR b -> (
-                match b with
-                | Comp -> 1
-                | Id -> 0
-                | Conecomp (n, _, _) | Cylcomp (n, _, _) | Cylstack n -> n
-                | Eh_half (n, _, _) | Eh_full (n, _, _) -> n)
-            | _ -> assert false
-          in
-          let d, func = dim_sub ctx s in
-          let newsusp = Some (d - inp - func) in
-          Sub (tmR, s, newsusp, b)
-      | Some _ -> Sub (tmR, s, i, b))
-  | BuiltinR b -> BuiltinR b
-  | Op (l, tm) -> Op (l, infer_susp_tm ctx tm)
-  | Inverse t -> Inverse (infer_susp_tm ctx t)
-  | Unit t -> Unit (infer_susp_tm ctx t)
-  | Meta -> Meta
-  | Letin_tm _ -> assert false
-
-and infer_susp_sub ctx = function
-  | [] -> []
-  | (tm, i) :: s -> (infer_susp_tm ctx tm, i) :: infer_susp_sub ctx s
-
-let infer_susp_ty ctx = function
-  | ObjR -> ObjR
-  | ArrR (u, v) -> ArrR (infer_susp_tm ctx u, infer_susp_tm ctx v)
-  | Letin_ty _ -> assert false
+module Make (Environment : Environments.S) = struct
+  open Environment
+
+  (** remove the let in in a term *)
+  let rec replace_tm l e =
+    match e with
+    | VarR a -> ( try replace_tm l (List.assoc a l) with Not_found -> VarR a)
+    | Sub (e, s, susp, b) -> Sub (replace_tm l e, replace_sub l s, susp, b)
+    | BuiltinR _ -> e
+    | Op (op_data, t) -> Op (op_data, replace_tm l t)
+    | Inverse t -> Inverse (replace_tm l t)
+    | Unit t -> Unit (replace_tm l t)
+    | Letin_tm (v, t, tm) -> replace_tm ((v, t) :: l) tm
+    | Meta -> Meta
+
+  and replace_sub l s =
+    match s with
+    | [] -> []
+    | (t, f) :: s -> (replace_tm l t, f) :: replace_sub l s
+
+  and replace_ty l t =
+    match t with
+    | ObjR -> t
+    | ArrR (u, v) -> ArrR (replace_tm l u, replace_tm l v)
+    | Letin_ty (v, t, ty) -> replace_ty ((v, t) :: l) ty
+
+  let remove_let_tm e = replace_tm [] e
+  let remove_let_ty e = replace_ty [] e
+
+  let rec var_in_ty x ty =
+    match ty with
+    | ObjR -> false
+    | ArrR (u, v) -> var_in_tm x u || var_in_tm x v
+    | Letin_ty _ -> Error.fatal "letin_ty constructors cannot appear here"
+
+  and var_in_tm x tm =
+    match tm with
+    | VarR v -> x = v
+    | Sub (_, s, _, _) -> List.exists (fun (t, _) -> var_in_tm x t) s
+    | BuiltinR _ -> false
+    | Inverse t -> var_in_tm x t
+    | Unit t -> var_in_tm x t
+    | Meta -> false
+    | Op (_, t) -> var_in_tm x t
+    | Letin_tm _ -> Error.fatal "letin_tm constructors cannot appear here"
+
+  let rec dim_ty ctx = function
+    | ObjR -> 0
+    | ArrR (u, _) -> 1 + dim_tm ctx u
+    | Letin_ty _ -> Error.fatal "letin_ty constructors cannot appear here"
+
+  and dim_tm ctx = function
+    | VarR v -> (
+        try dim_ty ctx (List.assoc v ctx)
+        with Not_found -> Error.unknown_id (Var.to_string v))
+    | Sub (tmR, s, i, _) ->
+        let func = List.fold_left (fun i (_, j) -> max i j) 0 s in
+        let d =
+          match tmR with
+          | VarR v -> Environment.dim_output v
+          | BuiltinR b -> dim_builtin b
+          | _ -> Error.fatal "ill-formed term"
+        in
+        let susp = match i with None -> 0 | Some i -> i in
+        d + func + susp
+    | BuiltinR b -> dim_builtin b
+    | Meta -> 0
+    | Op (_, tm) -> dim_tm ctx tm
+    | Inverse t -> dim_tm ctx t
+    | Unit t -> dim_tm ctx t + 1
+    | Letin_tm _ -> Error.fatal "letin_tm constructors cannot appear here"
+
+  and dim_builtin = function
+    | Comp -> 1
+    | Id -> 1
+    | Conecomp (n, _, m) | Cylcomp (n, _, m) -> max n m
+    | Cylstack n -> n
+    | Eh_half (n, _, _) | Eh_full (n, _, _) -> n + 1
+
+  let rec dim_sub ctx = function
+    | [] -> (0, 0)
+    | (t, f) :: s ->
+        let d1, f1 = dim_sub ctx s in
+        let d2 = dim_tm ctx t in
+        (max d1 d2, max f f1)
+
+  let rec infer_susp_tm ctx = function
+    | VarR v -> VarR v
+    | Sub (tmR, s, i, b) -> (
+        let s = infer_susp_sub ctx s in
+        match i with
+        | None ->
+            let inp =
+              match tmR with
+              | VarR v -> Environment.dim_input v
+              | BuiltinR b -> (
+                  match b with
+                  | Comp -> 1
+                  | Id -> 0
+                  | Conecomp (n, _, _) | Cylcomp (n, _, _) | Cylstack n -> n
+                  | Eh_half (n, _, _) | Eh_full (n, _, _) -> n)
+              | _ -> assert false
+            in
+            let d, func = dim_sub ctx s in
+            let newsusp = Some (d - inp - func) in
+            Sub (tmR, s, newsusp, b)
+        | Some _ -> Sub (tmR, s, i, b))
+    | BuiltinR b -> BuiltinR b
+    | Op (l, tm) -> Op (l, infer_susp_tm ctx tm)
+    | Inverse t -> Inverse (infer_susp_tm ctx t)
+    | Unit t -> Unit (infer_susp_tm ctx t)
+    | Meta -> Meta
+    | Letin_tm _ -> assert false
+
+  and infer_susp_sub ctx = function
+    | [] -> []
+    | (tm, i) :: s -> (infer_susp_tm ctx tm, i) :: infer_susp_sub ctx s
+
+  let infer_susp_ty ctx = function
+    | ObjR -> ObjR
+    | ArrR (u, v) -> ArrR (infer_susp_tm ctx u, infer_susp_tm ctx v)
+    | Letin_ty _ -> assert false
+end
diff --git a/lib/lib/raw.mli b/lib/lib/raw.mli
index 03b6a442..7d602b29 100644
--- a/lib/lib/raw.mli
+++ b/lib/lib/raw.mli
@@ -5,9 +5,12 @@ val string_of_builtin : builtin -> string
 val string_of_ty : tyR -> string
 val string_of_tm : tmR -> string
 val string_of_sub : subR -> string
-val remove_let_tm : tmR -> tmR
-val remove_let_ty : tyR -> tyR
-val var_in_ty : Var.t -> tyR -> bool
-val infer_susp_tm : (Var.t * tyR) list -> tmR -> tmR
-val infer_susp_ty : (Var.t * tyR) list -> tyR -> tyR
-val dim_tm : (Var.t * tyR) list -> tmR -> int
+
+module Make (_ : Environments.S) : sig
+  val remove_let_tm : tmR -> tmR
+  val remove_let_ty : tyR -> tyR
+  val var_in_ty : Var.t -> tyR -> bool
+  val infer_susp_tm : (Var.t * tyR) list -> tmR -> tmR
+  val infer_susp_ty : (Var.t * tyR) list -> tyR -> tyR
+  val dim_tm : (Var.t * tyR) list -> tmR -> int
+end
diff --git a/lib/meta_operations/builtin.ml b/lib/meta_operations/builtin.ml
index 6dee75f6..b222f2be 100644
--- a/lib/meta_operations/builtin.ml
+++ b/lib/meta_operations/builtin.ml
@@ -1,127 +1,94 @@
 open Common
-open Kernel
 
-module Memo = struct
-  let tbl = Hashtbl.create 97
-
-  let find i f =
-    try Hashtbl.find tbl i
-    with Not_found ->
-      let res = f i in
-      Hashtbl.add tbl i res;
-      res
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Comp = Comp.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
 
   let id _ =
     check_coh (Br []) (Arr (Obj, Var (Db 0), Var (Db 0))) ("builtin_id", 0, [])
-end
 
-module Comp = struct
-  let tdb i = Var (Var.Db i)
-  let tree i = Br (List.init i (fun _ -> Br []))
-  let x i = if i = 0 then (tdb 0, Obj) else (tdb ((2 * i) - 1), Obj)
-  let f i = (tdb (2 * i), Arr (Obj, fst @@ x (i - 1), fst @@ x i))
+  let ps_comp = Comp.tree
+  let comp_n = Comp.comp_n
+  let arity_comp = Comp.arity_comp
+  let comp = Comp.comp
+  let bcomp = Comp.bcomp
 
-  let comp_n arity =
-    let build_comp i =
-      let ps = tree i in
-      let pp_data = (Printf.sprintf "builtin_comp%i" arity, 0, []) in
-      Coh.check_noninv ps (fst (x 0)) (fst (x 0)) pp_data
+  let id_all_max ps =
+    let d = Unchecked.dim_ps ps in
+    let rec id_map l =
+      let t = Var (Db 0) in
+      match l with
+      | [] -> [ (t, false) ]
+      | Br [] :: l ->
+          (Coh (id (), [ (t, true) ]), true) :: (t, false) :: id_map l
+      | _ -> Error.fatal "identity must be inserted on maximal argument"
     in
-    Memo.find arity build_comp
-
-  let arity_comp s expl =
-    let n = List.length s in
-    if expl || !Settings.explicit_substitutions then (n - 1) / 2 else n
-
-  let comp s expl =
-    let arity = arity_comp s expl in
-    comp_n arity
-
-  let bcomp x y f z g =
-    let comp = comp_n 2 in
-    let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
-    Coh (comp, sub)
-end
-
-let ps_comp = Comp.tree
-let comp_n = Comp.comp_n
-let arity_comp = Comp.arity_comp
-let comp = Comp.comp
-let bcomp = Comp.bcomp
-let id = Memo.id
-
-let id_all_max ps =
-  let d = Unchecked.dim_ps ps in
-  let rec id_map l =
-    let t = Var (Db 0) in
-    match l with
-    | [] -> [ (t, false) ]
-    | Br [] :: l -> (Coh (id (), [ (t, true) ]), true) :: (t, false) :: id_map l
-    | _ -> Error.fatal "identity must be inserted on maximal argument"
-  in
-  let rec aux i ps =
-    match (i, ps) with
-    | _, Br [] -> [ (Var (Db 0), true) ]
-    | 0, Br l -> id_map l
-    | i, Br l ->
-        Unchecked.suspwedge_subs_ps
-          (List.map (aux (i - 1)) l)
-          (List.map Unchecked.ps_bdry l)
-  in
-  aux (d - 1) ps
+    let rec aux i ps =
+      match (i, ps) with
+      | _, Br [] -> [ (Var (Db 0), true) ]
+      | 0, Br l -> id_map l
+      | i, Br l ->
+          Unchecked.suspwedge_subs_ps
+            (List.map (aux (i - 1)) l)
+            (List.map Unchecked.ps_bdry l)
+    in
+    aux (d - 1) ps
 
-let assoc =
-  let tdb i = Var (Db i) in
-  let src =
-    bcomp (tdb 0) (tdb 1) (tdb 2) (tdb 5)
-      (bcomp (tdb 1) (tdb 3) (tdb 4) (tdb 5) (tdb 6))
-  in
-  let tgt =
-    bcomp (tdb 0) (tdb 3)
-      (bcomp (tdb 0) (tdb 1) (tdb 2) (tdb 3) (tdb 4))
-      (tdb 5) (tdb 6)
-  in
-  Coh.check_inv (ps_comp 3) src tgt ("assoc", 0, [])
+  let assoc =
+    let tdb i = Var (Db i) in
+    let src =
+      bcomp (tdb 0) (tdb 1) (tdb 2) (tdb 5)
+        (bcomp (tdb 1) (tdb 3) (tdb 4) (tdb 5) (tdb 6))
+    in
+    let tgt =
+      bcomp (tdb 0) (tdb 3)
+        (bcomp (tdb 0) (tdb 1) (tdb 2) (tdb 3) (tdb 4))
+        (tdb 5) (tdb 6)
+    in
+    Coh.check_inv (ps_comp 3) src tgt ("assoc", 0, [])
 
-let unbiased_unitor ps t =
-  let bdry = Unchecked.ps_bdry ps in
-  let src =
-    let coh = Coh.check_noninv ps t t ("endo", 0, []) in
-    Coh (coh, id_all_max ps)
-  in
-  let a = Tm.ty (check_term (Ctx.check (Unchecked.ps_to_ctx bdry)) t) in
-  let da = Unchecked.dim_ty a in
-  let sub_base = Unchecked.ty_to_sub_ps a in
-  let tgt = Coh (Suspension.coh (Some da) (id ()), (t, true) :: sub_base) in
-  Coh.check_inv bdry src tgt ("unbiased_unitor", 0, [])
+  let unbiased_unitor ps t =
+    let bdry = Unchecked.ps_bdry ps in
+    let src =
+      let coh = Coh.check_noninv ps t t ("endo", 0, []) in
+      Coh (coh, id_all_max ps)
+    in
+    let a = Tm.ty (check_term (Ctx.check (Unchecked.ps_to_ctx bdry)) t) in
+    let da = Unchecked.dim_ty a in
+    let sub_base = Unchecked.ty_to_sub_ps a in
+    let tgt = Coh (Suspension.coh (Some da) (id ()), (t, true) :: sub_base) in
+    Coh.check_inv bdry src tgt ("unbiased_unitor", 0, [])
 
-let tdb i = Var (Var.Db i)
-let wcomp = ref (fun _ -> Error.fatal "Uninitialised forward reference wcomp")
+  let tdb i = Var (Var.Db i)
+  let wcomp = Functorialisation.wcomp
 
-(*
+  (*
   (a *_n b) *_0 g -> (a *_0 g) *_n (b *_0 g)
     https://q.uiver.app/#q=WzAsMyxbMCwwLCIwIl0sWzIsMCwiMSJdLFs0LDAsIjciXSxbMCwxLCIyIiwwLHsiY3VydmUiOi01fV0sWzAsMSwiNSIsMix7ImN1cnZlIjo1fV0sWzAsMSwiMyIsMV0sWzEsMiwiOCIsMV0sWzMsNSwiNCIsMix7InNob3J0ZW4iOnsic291cmNlIjoyMCwidGFyZ2V0IjoyMH19XSxbNSw0LCI2IiwyLHsic2hvcnRlbiI6eyJzb3VyY2UiOjIwLCJ0YXJnZXQiOjIwfX1dXQ==
 *)
-let intch_comp_n0_coh n =
-  let rec ty n =
-    match n with
-    | 0 -> Obj
-    | _ -> Arr (ty (n - 1), tdb ((2 * n) - 2), tdb ((2 * n) - 1))
-  in
-  let fty = ty n in
-  let a = (tdb ((2 * n) + 2), Arr (fty, tdb (2 * n), tdb ((2 * n) + 1))) in
-  let b =
-    (tdb ((2 * n) + 4), Arr (fty, tdb ((2 * n) + 1), tdb ((2 * n) + 3)))
-  in
-  let g = (tdb ((2 * n) + 6), Arr (Obj, tdb 1, tdb ((2 * n) + 5))) in
-  let s, _ = !wcomp (!wcomp a n b) 0 g in
-  let t, _ = !wcomp (!wcomp a 0 g) n (!wcomp b 0 g) in
-  let ps = Br [ Br []; Suspension.ps (Some (n - 1)) (Br [ Br []; Br [] ]) ] in
-  Coh.check_inv ps s t (Printf.sprintf "builtin_comp_%d_0_intch" n, 0, [])
+  let intch_comp_n0_coh n =
+    let rec ty n =
+      match n with
+      | 0 -> Obj
+      | _ -> Arr (ty (n - 1), tdb ((2 * n) - 2), tdb ((2 * n) - 1))
+    in
+    let fty = ty n in
+    let a = (tdb ((2 * n) + 2), Arr (fty, tdb (2 * n), tdb ((2 * n) + 1))) in
+    let b =
+      (tdb ((2 * n) + 4), Arr (fty, tdb ((2 * n) + 1), tdb ((2 * n) + 3)))
+    in
+    let g = (tdb ((2 * n) + 6), Arr (Obj, tdb 1, tdb ((2 * n) + 5))) in
+    let s, _ = wcomp (wcomp a n b) 0 g in
+    let t, _ = wcomp (wcomp a 0 g) n (wcomp b 0 g) in
+    let ps = Br [ Br []; Suspension.ps (Some (n - 1)) (Br [ Br []; Br [] ]) ] in
+    Coh.check_inv ps s t (Printf.sprintf "builtin_comp_%d_0_intch" n, 0, [])
 
-(*
+  (*
   For n>m
   (a *_n b) *_m c -> (a *_m c) *_n (b *_m c)
 *)
-let intch_comp_nm_coh n m =
-  Suspension.coh (Some (m - 1)) (intch_comp_n0_coh (n - m))
+  let intch_comp_nm_coh n m =
+    Suspension.coh (Some (m - 1)) (intch_comp_n0_coh (n - m))
+end
diff --git a/lib/meta_operations/builtin.mli b/lib/meta_operations/builtin.mli
index 8624cc6b..20bbcb2f 100644
--- a/lib/meta_operations/builtin.mli
+++ b/lib/meta_operations/builtin.mli
@@ -1,19 +1,16 @@
-open Raw_types
 open Common
-open Kernel
+open Raw_types
 
-module Comp : sig
-  val tree : int -> ps
-  val x : int -> constr
-  val f : int -> constr
-end
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val wcomp : (tm * ty -> int -> tm * ty -> tm * ty) ref
-val ps_comp : int -> ps
-val comp_n : int -> Coh.t
-val comp : subR -> bool -> Coh.t
-val arity_comp : subR -> bool -> int
-val id : unit -> Coh.t
-val assoc : Coh.t
-val unbiased_unitor : ps -> tm -> Coh.t
-val intch_comp_nm_coh : int -> int -> Coh.t
+  val wcomp : tm * ty -> int -> tm * ty -> tm * ty
+  val ps_comp : int -> ps
+  val comp_n : int -> Coh.t
+  val comp : subR -> bool -> Coh.t
+  val arity_comp : subR -> bool -> int
+  val id : unit -> Coh.t
+  val assoc : Coh.t
+  val unbiased_unitor : ps -> tm -> Coh.t
+  val intch_comp_nm_coh : int -> int -> Coh.t
+end
diff --git a/lib/meta_operations/comp.ml b/lib/meta_operations/comp.ml
new file mode 100644
index 00000000..0bb3324f
--- /dev/null
+++ b/lib/meta_operations/comp.ml
@@ -0,0 +1,42 @@
+open Common
+
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+
+  module Memo = struct
+    let tbl = Hashtbl.create 97
+
+    let find i f =
+      try Hashtbl.find tbl i
+      with Not_found ->
+        let res = f i in
+        Hashtbl.add tbl i res;
+        res
+  end
+
+  let tdb i = Var (Var.Db i)
+  let tree i = Br (List.init i (fun _ -> Br []))
+  let x i = if i = 0 then (tdb 0, Obj) else (tdb ((2 * i) - 1), Obj)
+  let f i = (tdb (2 * i), Arr (Obj, fst @@ x (i - 1), fst @@ x i))
+
+  let comp_n arity =
+    let build_comp i =
+      let ps = tree i in
+      let pp_data = (Printf.sprintf "builtin_comp%i" arity, 0, []) in
+      Coh.check_noninv ps (fst (x 0)) (fst (x 0)) pp_data
+    in
+    Memo.find arity build_comp
+
+  let arity_comp s expl =
+    let n = List.length s in
+    if expl || !Settings.explicit_substitutions then (n - 1) / 2 else n
+
+  let comp s expl =
+    let arity = arity_comp s expl in
+    comp_n arity
+
+  let bcomp x y f z g =
+    let comp = comp_n 2 in
+    let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
+    Coh (comp, sub)
+end
diff --git a/lib/meta_operations/comp.mli b/lib/meta_operations/comp.mli
new file mode 100644
index 00000000..33beb386
--- /dev/null
+++ b/lib/meta_operations/comp.mli
@@ -0,0 +1,14 @@
+open Common
+open Raw_types
+
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
+
+  val tree : int -> ps
+  val x : int -> constr
+  val f : int -> constr
+  val comp_n : int -> Coh.t
+  val comp : subR -> bool -> Coh.t
+  val arity_comp : subR -> bool -> int
+  val bcomp : tm -> tm -> tm -> tm -> tm -> tm
+end
diff --git a/lib/meta_operations/cones.ml b/lib/meta_operations/cones.ml
index 2e68f51e..2eaf7f51 100644
--- a/lib/meta_operations/cones.ml
+++ b/lib/meta_operations/cones.ml
@@ -1,376 +1,393 @@
 open Common
-open Kernel
 
-let wcomp = Construct.wcomp
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+  module Construct = Construct.Make (Theory)
+  module Opposite = Opposite.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
 
-(* Cone contexts *)
-module Cone = struct
-  let tbl = Hashtbl.create 97
+  let wcomp = Construct.wcomp
 
-  let rec ctx n =
-    match Hashtbl.find_opt tbl n with
-    | Some res -> res
-    | None ->
-        let res =
-          match n with
-          | n when n <= 0 ->
-              ( Unchecked.ps_to_ctx (Br []),
-                Var.Db 0,
-                Var.Db 0,
-                Var.Db 0,
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ],
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ] )
-          | 1 ->
-              ( Unchecked.ps_to_ctx (Br [ Br [] ]),
-                Var.Db 0,
-                Var.Db 1,
-                Var.Db 2,
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ],
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ] )
-          | n ->
-              let ctx, b, a, f, _, _ = ctx (n - 1) in
-              let id = Unchecked.identity ctx in
-              let ctx = Functorialisation.ctx ctx [ b; f ] in
-              let names = Unchecked.db_level_sub_inv ctx in
-              let ctx, _, _ = Unchecked.db_levels ctx in
-              let rename x = Display_maps.var_apply_sub x names in
-              let src = Unchecked.sub_apply_sub id names in
-              let tgt_predb =
-                List.map
-                  (fun (x, (y, e)) ->
-                    match y with
-                    | Var a when a = b || a = f -> (x, (Var (Var.Plus a), e))
-                    | _ -> (x, (y, e)))
-                  id
-              in
-              let tgt = Unchecked.sub_apply_sub tgt_predb names in
-              let b = Var.Bridge b in
-              let f = Var.Bridge f in
-              (ctx, rename b, rename a, rename f, src, tgt)
-        in
-        Hashtbl.add tbl n res;
-        res
+  (* Cone contexts *)
+  module Cone = struct
+    let tbl = Hashtbl.create 97
 
-  let base n =
-    let _, b, _, _, _, _ = ctx n in
-    b
+    let rec ctx n =
+      match Hashtbl.find_opt tbl n with
+      | Some res -> res
+      | None ->
+          let res =
+            match n with
+            | n when n <= 0 ->
+                ( Unchecked.ps_to_ctx (Br []),
+                  Var.Db 0,
+                  Var.Db 0,
+                  Var.Db 0,
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ],
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ] )
+            | 1 ->
+                ( Unchecked.ps_to_ctx (Br [ Br [] ]),
+                  Var.Db 0,
+                  Var.Db 1,
+                  Var.Db 2,
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ],
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ] )
+            | n ->
+                let ctx, b, a, f, _, _ = ctx (n - 1) in
+                let id = Unchecked.identity ctx in
+                let ctx = Functorialisation.ctx ctx [ b; f ] in
+                let names = Unchecked.db_level_sub_inv ctx in
+                let ctx, _, _ = Unchecked.db_levels ctx in
+                let rename x = Display_maps.var_apply_sub x names in
+                let src = Unchecked.sub_apply_sub id names in
+                let tgt_predb =
+                  List.map
+                    (fun (x, (y, e)) ->
+                      match y with
+                      | Var a when a = b || a = f -> (x, (Var (Var.Plus a), e))
+                      | _ -> (x, (y, e)))
+                    id
+                in
+                let tgt = Unchecked.sub_apply_sub tgt_predb names in
+                let b = Var.Bridge b in
+                let f = Var.Bridge f in
+                (ctx, rename b, rename a, rename f, src, tgt)
+          in
+          Hashtbl.add tbl n res;
+          res
 
-  let filler n =
-    let _, _, _, f, _, _ = ctx n in
-    f
+    let base n =
+      let _, b, _, _, _, _ = ctx n in
+      b
 
-  let apex n =
-    let _, _, a, _, _, _ = ctx n in
-    a
+    let filler n =
+      let _, _, _, f, _, _ = ctx n in
+      f
 
-  let bdry_left_gen n =
-    let _, _, _, _, bdry, _ = ctx n in
-    bdry
+    let apex n =
+      let _, _, a, _, _, _ = ctx n in
+      a
 
-  let bdry_right_gen n =
-    let _, _, _, _, _, bdry = ctx n in
-    bdry
+    let bdry_left_gen n =
+      let _, _, _, _, bdry, _ = ctx n in
+      bdry
 
-  let ctx n =
-    let ctx, _, _, _, _, _ = ctx n in
-    ctx
+    let bdry_right_gen n =
+      let _, _, _, _, _, bdry = ctx n in
+      bdry
 
-  let rec bdry_left n k =
-    if n <= k then Unchecked.identity (ctx n)
-    else if n = k + 1 then bdry_left_gen n
-    else Unchecked.sub_apply_sub (bdry_left (n - 1) k) (bdry_left_gen n)
+    let ctx n =
+      let ctx, _, _, _, _, _ = ctx n in
+      ctx
 
-  let rec bdry_right n k =
-    if n <= k then Unchecked.identity (ctx n)
-    else if n = k + 1 then bdry_right_gen n
-    else Unchecked.sub_apply_sub (bdry_right (n - 1) k) (bdry_right_gen n)
-end
+    let rec bdry_left n k =
+      if n <= k then Unchecked.identity (ctx n)
+      else if n = k + 1 then bdry_left_gen n
+      else Unchecked.sub_apply_sub (bdry_left (n - 1) k) (bdry_left_gen n)
+
+    let rec bdry_right n k =
+      if n <= k then Unchecked.identity (ctx n)
+      else if n = k + 1 then bdry_right_gen n
+      else Unchecked.sub_apply_sub (bdry_right (n - 1) k) (bdry_right_gen n)
+  end
 
-(* Cone inductive relation : a (n+1)-cone is a suspended opposite of a n-cone *)
-module Induct : sig
-  val ctx : int -> ctx
-  val sub : int -> sub
-end = struct
-  (* The suspension opposite of a cone context *)
-  let ctx n =
-    let op_data = List.init (n - 1) (fun i -> i + 1) in
-    let ctx =
-      Suspension.ctx (Some 1) (Opposite.ctx (Cone.ctx (n - 1)) op_data)
-    in
-    let ctx, _, _ = Unchecked.db_levels ctx in
-    ctx
+  (* Cone inductive relation : a (n+1)-cone is a suspended opposite of a n-cone *)
+  module Induct : sig
+    val ctx : int -> ctx
+    val sub : int -> sub
+  end = struct
+    (* The suspension opposite of a cone context *)
+    let ctx n =
+      let op_data = List.init (n - 1) (fun i -> i + 1) in
+      let ctx =
+        Suspension.ctx (Some 1) (Opposite.ctx (Cone.ctx (n - 1)) op_data)
+      in
+      let ctx, _, _ = Unchecked.db_levels ctx in
+      ctx
 
-  (* substitution from the cone context to the suspension opposite of a cone.
+    (* substitution from the cone context to the suspension opposite of a cone.
      This function returns a horribly hardcoded list, even though the target
      context is not a pasting scheme *)
-  let fake_sub_ps_unsafe n =
-    let ctx = Cone.ctx n in
-    let with_type v = (Var v, fst (List.assoc v ctx)) in
-    let b k = Display_maps.var_apply_sub (Cone.base k) (Cone.bdry_left n k) in
-    let bP k = Display_maps.var_apply_sub (Cone.base k) (Cone.bdry_right n k) in
-    let f k = Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_left n k) in
-    let fP k =
-      Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_right n k)
-    in
-    let fP1 = with_type (fP 1) in
-    let b k = with_type (b k) in
-    let bP k = with_type (bP k) in
-    List.concat
-      [
-        [ (Var (Cone.filler n), true) ];
-        List.init
-          (2 * (n - 2))
-          (fun i ->
-            let i = i + 2 in
-            let v =
-              if i mod 2 = 0 then f (n - (i / 2)) else fP (n - ((i - 1) / 2))
-            in
-            (Var v, false));
-        [ (Var (f 1), false); (fst @@ wcomp (b n) 0 fP1, false) ];
-        List.init
-          (2 * (n - 2))
-          (fun i ->
-            let i = i + 2 in
-            let v =
-              if i mod 2 = 0 then b (n - (i / 2)) else bP (n - ((i - 1) / 2))
-            in
-            (fst @@ wcomp v 0 fP1, false));
-        [ (Var (Cone.apex n), false); (Var (Cone.base 1), false) ];
-      ]
+    let fake_sub_ps_unsafe n =
+      let ctx = Cone.ctx n in
+      let with_type v = (Var v, fst (List.assoc v ctx)) in
+      let b k = Display_maps.var_apply_sub (Cone.base k) (Cone.bdry_left n k) in
+      let bP k =
+        Display_maps.var_apply_sub (Cone.base k) (Cone.bdry_right n k)
+      in
+      let f k =
+        Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_left n k)
+      in
+      let fP k =
+        Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_right n k)
+      in
+      let fP1 = with_type (fP 1) in
+      let b k = with_type (b k) in
+      let bP k = with_type (bP k) in
+      List.concat
+        [
+          [ (Var (Cone.filler n), true) ];
+          List.init
+            (2 * (n - 2))
+            (fun i ->
+              let i = i + 2 in
+              let v =
+                if i mod 2 = 0 then f (n - (i / 2)) else fP (n - ((i - 1) / 2))
+              in
+              (Var v, false));
+          [ (Var (f 1), false); (fst @@ wcomp (b n) 0 fP1, false) ];
+          List.init
+            (2 * (n - 2))
+            (fun i ->
+              let i = i + 2 in
+              let v =
+                if i mod 2 = 0 then b (n - (i / 2)) else bP (n - ((i - 1) / 2))
+              in
+              (fst @@ wcomp v 0 fP1, false));
+          [ (Var (Cone.apex n), false); (Var (Cone.base 1), false) ];
+        ]
 
-  let sub n = Unchecked.sub_ps_to_sub (fake_sub_ps_unsafe n)
-end
+    let sub n = Unchecked.sub_ps_to_sub (fake_sub_ps_unsafe n)
+  end
 
-(* Binary Composition of cones *)
+  (* Binary Composition of cones *)
 
-module Codim1 = struct
-  let tbl_comp_codim1 = Hashtbl.create 97
+  module Codim1 = struct
+    let tbl_comp_codim1 = Hashtbl.create 97
 
-  let ctx n =
-    match n with
-    | n when n <= 1 -> assert false
-    | n -> (
-        match Hashtbl.find_opt tbl_comp_codim1 n with
-        | Some res -> res
-        | None ->
-            let ctx, right_incl =
-              Display_maps.pullback (Cone.ctx n)
-                (Cone.bdry_right n (n - 1))
-                (Cone.ctx n)
-                (Cone.bdry_left n (n - 1))
-            in
-            let names = Unchecked.db_level_sub_inv ctx in
-            let ctx, _, _ = Unchecked.db_levels ctx in
-            let right_incl = Unchecked.sub_apply_sub right_incl names in
-            let res = (ctx, right_incl) in
-            Hashtbl.add tbl_comp_codim1 n res;
-            res)
+    let ctx n =
+      match n with
+      | n when n <= 1 -> assert false
+      | n -> (
+          match Hashtbl.find_opt tbl_comp_codim1 n with
+          | Some res -> res
+          | None ->
+              let ctx, right_incl =
+                Display_maps.pullback (Cone.ctx n)
+                  (Cone.bdry_right n (n - 1))
+                  (Cone.ctx n)
+                  (Cone.bdry_left n (n - 1))
+              in
+              let names = Unchecked.db_level_sub_inv ctx in
+              let ctx, _, _ = Unchecked.db_levels ctx in
+              let right_incl = Unchecked.sub_apply_sub right_incl names in
+              let res = (ctx, right_incl) in
+              Hashtbl.add tbl_comp_codim1 n res;
+              res)
 
-  let right_incl n = snd @@ ctx n
-  let ctx n = fst @@ ctx n
-  let left_base n = Cone.base n
-  let right_base n = Display_maps.var_apply_sub (Cone.base n) (right_incl n)
-  let left_filler n = Cone.filler n
-  let right_filler n = Display_maps.var_apply_sub (Cone.filler n) (right_incl n)
+    let right_incl n = snd @@ ctx n
+    let ctx n = fst @@ ctx n
+    let left_base n = Cone.base n
+    let right_base n = Display_maps.var_apply_sub (Cone.base n) (right_incl n)
+    let left_filler n = Cone.filler n
 
-  let compose_dim2 () =
-    let with_type ctx x = (Var x, fst (List.assoc x ctx)) in
-    let ctx = ctx 2 in
-    let right_incl = right_incl 2 in
-    let left_filler = with_type ctx (left_filler 2) in
-    let right_filler = with_type ctx (right_filler 2) in
-    let left_base = with_type ctx (left_base 2) in
-    let right_base = with_type ctx (right_base 2) in
-    let tm_1 = wcomp left_filler 1 (wcomp left_base 0 right_filler) in
-    let leftmost_pt, midpoint =
-      match snd left_base with Arr (_, s, t) -> (s, t) | _ -> assert false
-    in
-    let rightmost_pt =
-      match snd right_base with Arr (_, _, t) -> t | _ -> assert false
-    in
-    let sub_ps =
-      [
-        (Unchecked.tm_apply_sub (Var (Var.Db 5)) right_incl, true);
-        (Var (Cone.apex 2), false);
-        (fst right_base, true);
-        (rightmost_pt, false);
-        (fst left_base, true);
-        (midpoint, false);
-        (leftmost_pt, false);
-      ]
-    in
-    let assoc = Builtin.assoc in
-    let _, assoc_ty, _ = Coh.forget assoc in
-    let tm_2 =
-      ( Coh (Builtin.assoc, sub_ps),
-        Unchecked.ty_apply_sub assoc_ty (Unchecked.sub_ps_to_sub sub_ps) )
-    in
-    let tm, _ = wcomp tm_1 1 tm_2 in
-    let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" 2 1 2 in
-    check_term (Ctx.check ctx) ~name:(name, 0, []) tm
+    let right_filler n =
+      Display_maps.var_apply_sub (Cone.filler n) (right_incl n)
 
-  let intch n =
-    let with_type ctx x = (Var x, fst (List.assoc x ctx)) in
-    let ctx_comp = ctx n in
-    let f k = Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_left n k) in
-    let fP k =
-      Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_right n k)
-    in
-    let fP k = Display_maps.var_apply_sub (fP k) (right_incl n) in
-    let lb = left_base n in
-    let rb = right_base n in
-    let inner_intch =
-      Construct.intch_comp_nm (with_type ctx_comp lb) (with_type ctx_comp rb)
-        (with_type ctx_comp (fP 1))
-    in
-    let inner_intch =
-      if n mod 2 = 0 then Construct.inv inner_intch else inner_intch
-    in
-    let rec wrap k =
-      if k = 0 then inner_intch
-      else if k mod 2 <> 0 then
-        let f = with_type ctx_comp (f (k + 1)) in
-        wcomp f k (wrap (k - 1))
-      else
-        let f = with_type ctx_comp (fP (k + 1)) in
-        wcomp (wrap (k - 1)) k f
-    in
-    wrap (n - 2)
+    let compose_dim2 () =
+      let with_type ctx x = (Var x, fst (List.assoc x ctx)) in
+      let ctx = ctx 2 in
+      let right_incl = right_incl 2 in
+      let left_filler = with_type ctx (left_filler 2) in
+      let right_filler = with_type ctx (right_filler 2) in
+      let left_base = with_type ctx (left_base 2) in
+      let right_base = with_type ctx (right_base 2) in
+      let tm_1 = wcomp left_filler 1 (wcomp left_base 0 right_filler) in
+      let leftmost_pt, midpoint =
+        match snd left_base with Arr (_, s, t) -> (s, t) | _ -> assert false
+      in
+      let rightmost_pt =
+        match snd right_base with Arr (_, _, t) -> t | _ -> assert false
+      in
+      let sub_ps =
+        [
+          (Unchecked.tm_apply_sub (Var (Var.Db 5)) right_incl, true);
+          (Var (Cone.apex 2), false);
+          (fst right_base, true);
+          (rightmost_pt, false);
+          (fst left_base, true);
+          (midpoint, false);
+          (leftmost_pt, false);
+        ]
+      in
+      let assoc = Builtin.assoc in
+      let _, assoc_ty, _ = Coh.forget assoc in
+      let tm_2 =
+        ( Coh (Builtin.assoc, sub_ps),
+          Unchecked.ty_apply_sub assoc_ty (Unchecked.sub_ps_to_sub sub_ps) )
+      in
+      let tm, _ = wcomp tm_1 1 tm_2 in
+      let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" 2 1 2 in
+      check_term (Ctx.check ctx) ~name:(name, 0, []) tm
 
-  let rec compose n =
-    match n with
-    | n when n <= 1 -> assert false
-    | 2 -> compose_dim2 ()
-    | n ->
-        let right_incl_prev = right_incl (n - 1) in
-        let ctx_comp = ctx n in
-        let right_incl = right_incl n in
-        let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" n 1 n in
-        let suspopcomp =
-          let op_data = List.init (n - 1) (fun i -> i + 1) in
-          let comp =
-            Suspension.checked_tm (Some 1)
-              (Opposite.checked_tm (compose (n - 1)) op_data)
-          in
-          let ind_sub = Induct.sub n in
-          let sub =
-            Display_maps.glue
-              (Unchecked.sub_apply_sub ind_sub right_incl)
-              ind_sub
-              (Suspension.sub (Some 1) (Opposite.sub right_incl_prev op_data))
-              (Induct.ctx n)
-              (Suspension.sub (Some 1)
-                 (Opposite.sub (Cone.bdry_left (n - 1) (n - 2)) op_data))
-          in
-          check_term (Ctx.check ctx_comp) ~name:(name, 0, []) (App (comp, sub))
-        in
-        let intch = intch n in
-        let socomp = (Tm.develop suspopcomp, Tm.ty suspopcomp) in
-        let tm, _ =
-          if n mod 2 = 0 then wcomp socomp (n - 1) intch
-          else wcomp intch (n - 1) socomp
-        in
-        check_term (Ctx.check ctx_comp) ~name:(name, 0, []) tm
-end
+    let intch n =
+      let with_type ctx x = (Var x, fst (List.assoc x ctx)) in
+      let ctx_comp = ctx n in
+      let f k =
+        Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_left n k)
+      in
+      let fP k =
+        Display_maps.var_apply_sub (Cone.filler k) (Cone.bdry_right n k)
+      in
+      let fP k = Display_maps.var_apply_sub (fP k) (right_incl n) in
+      let lb = left_base n in
+      let rb = right_base n in
+      let inner_intch =
+        Construct.intch_comp_nm (with_type ctx_comp lb) (with_type ctx_comp rb)
+          (with_type ctx_comp (fP 1))
+      in
+      let inner_intch =
+        if n mod 2 = 0 then Construct.inv inner_intch else inner_intch
+      in
+      let rec wrap k =
+        if k = 0 then inner_intch
+        else if k mod 2 <> 0 then
+          let f = with_type ctx_comp (f (k + 1)) in
+          wcomp f k (wrap (k - 1))
+        else
+          let f = with_type ctx_comp (fP (k + 1)) in
+          wcomp (wrap (k - 1)) k f
+      in
+      wrap (n - 2)
 
-module Composition = struct
-  let rec ctx n m k =
-    if n > m then
-      let ctx, lb, lf, rb, rf = ctx (n - 1) m k in
-      let ctx = Functorialisation.ctx ctx [ lb; lf ] in
-      let names = Unchecked.db_level_sub_inv ctx in
-      let ctx, _, _ = Unchecked.db_levels ctx in
-      let rename x = Display_maps.var_apply_sub x names in
-      let lb = Var.Bridge lb in
-      let lf = Var.Bridge lf in
-      (ctx, rename lb, rename lf, rename rb, rename rf)
-    else if m > n then
-      let ctx, lb, lf, rb, rf = ctx n (m - 1) k in
-      let ctx = Functorialisation.ctx ctx [ rb; rf ] in
-      let names = Unchecked.db_level_sub_inv ctx in
-      let ctx, _, _ = Unchecked.db_levels ctx in
-      let rename x = Display_maps.var_apply_sub x names in
-      let rb = Var.Bridge rb in
-      let rf = Var.Bridge rf in
-      (ctx, rename lb, rename lf, rename rb, rename rf)
-    else
-      match n - k with
-      | i when i <= 0 -> assert false
-      | 1 ->
-          let lb = Cone.base n in
-          let lf = Cone.filler n in
-          let rb =
-            Display_maps.var_apply_sub (Cone.base n) (Codim1.right_incl n)
+    let rec compose n =
+      match n with
+      | n when n <= 1 -> assert false
+      | 2 -> compose_dim2 ()
+      | n ->
+          let right_incl_prev = right_incl (n - 1) in
+          let ctx_comp = ctx n in
+          let right_incl = right_incl n in
+          let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" n 1 n in
+          let suspopcomp =
+            let op_data = List.init (n - 1) (fun i -> i + 1) in
+            let comp =
+              Suspension.checked_tm (Some 1)
+                (Opposite.checked_tm (compose (n - 1)) op_data)
+            in
+            let ind_sub = Induct.sub n in
+            let sub =
+              Display_maps.glue
+                (Unchecked.sub_apply_sub ind_sub right_incl)
+                ind_sub
+                (Suspension.sub (Some 1) (Opposite.sub right_incl_prev op_data))
+                (Induct.ctx n)
+                (Suspension.sub (Some 1)
+                   (Opposite.sub (Cone.bdry_left (n - 1) (n - 2)) op_data))
+            in
+            check_term (Ctx.check ctx_comp) ~name:(name, 0, [])
+              (App (comp, sub))
           in
-          let rf =
-            Display_maps.var_apply_sub (Cone.filler n) (Codim1.right_incl n)
+          let intch = intch n in
+          let socomp = (Tm.develop suspopcomp, Tm.ty suspopcomp) in
+          let tm, _ =
+            if n mod 2 = 0 then wcomp socomp (n - 1) intch
+            else wcomp intch (n - 1) socomp
           in
-          (Codim1.ctx n, lb, lf, rb, rf)
-      | _ ->
-          let ctx, lb, lf, rb, rf = ctx (n - 1) (m - 1) k in
-          let ctx = Functorialisation.ctx ctx [ lb; lf; rb; rf ] in
-          let names = Unchecked.db_level_sub_inv ctx in
-          let ctx, _, _ = Unchecked.db_levels ctx in
-          let rename x = Display_maps.var_apply_sub x names in
-          let lb = Var.Bridge lb in
-          let lf = Var.Bridge lf in
-          let rb = Var.Bridge rb in
-          let rf = Var.Bridge rf in
-          (ctx, rename lb, rename lf, rename rb, rename rf)
+          check_term (Ctx.check ctx_comp) ~name:(name, 0, []) tm
+  end
+
+  module Composition = struct
+    let rec ctx n m k =
+      if n > m then
+        let ctx, lb, lf, rb, rf = ctx (n - 1) m k in
+        let ctx = Functorialisation.ctx ctx [ lb; lf ] in
+        let names = Unchecked.db_level_sub_inv ctx in
+        let ctx, _, _ = Unchecked.db_levels ctx in
+        let rename x = Display_maps.var_apply_sub x names in
+        let lb = Var.Bridge lb in
+        let lf = Var.Bridge lf in
+        (ctx, rename lb, rename lf, rename rb, rename rf)
+      else if m > n then
+        let ctx, lb, lf, rb, rf = ctx n (m - 1) k in
+        let ctx = Functorialisation.ctx ctx [ rb; rf ] in
+        let names = Unchecked.db_level_sub_inv ctx in
+        let ctx, _, _ = Unchecked.db_levels ctx in
+        let rename x = Display_maps.var_apply_sub x names in
+        let rb = Var.Bridge rb in
+        let rf = Var.Bridge rf in
+        (ctx, rename lb, rename lf, rename rb, rename rf)
+      else
+        match n - k with
+        | i when i <= 0 -> assert false
+        | 1 ->
+            let lb = Cone.base n in
+            let lf = Cone.filler n in
+            let rb =
+              Display_maps.var_apply_sub (Cone.base n) (Codim1.right_incl n)
+            in
+            let rf =
+              Display_maps.var_apply_sub (Cone.filler n) (Codim1.right_incl n)
+            in
+            (Codim1.ctx n, lb, lf, rb, rf)
+        | _ ->
+            let ctx, lb, lf, rb, rf = ctx (n - 1) (m - 1) k in
+            let ctx = Functorialisation.ctx ctx [ lb; lf; rb; rf ] in
+            let names = Unchecked.db_level_sub_inv ctx in
+            let ctx, _, _ = Unchecked.db_levels ctx in
+            let rename x = Display_maps.var_apply_sub x names in
+            let lb = Var.Bridge lb in
+            let lf = Var.Bridge lf in
+            let rb = Var.Bridge rb in
+            let rf = Var.Bridge rf in
+            (ctx, rename lb, rename lf, rename rb, rename rf)
 
-  let left_base n m k =
-    let _, lb, _, _, _ = ctx n m k in
-    lb
+    let left_base n m k =
+      let _, lb, _, _, _ = ctx n m k in
+      lb
 
-  let right_base n m k =
-    let _, _, _, rb, _ = ctx n m k in
-    rb
+    let right_base n m k =
+      let _, _, _, rb, _ = ctx n m k in
+      rb
 
-  let left_filler n m k =
-    let _, _, lf, _, _ = ctx n m k in
-    lf
+    let left_filler n m k =
+      let _, _, lf, _, _ = ctx n m k in
+      lf
 
-  let right_filler n m k =
-    let _, _, _, _, rf = ctx n m k in
-    rf
+    let right_filler n m k =
+      let _, _, _, _, rf = ctx n m k in
+      rf
 
-  let tbl = Hashtbl.create 97
+    let tbl = Hashtbl.create 97
 
-  let rec compose n m k =
-    match Hashtbl.find_opt tbl (n, m, k) with
-    | Some res -> res
-    | None ->
-        let tm =
-          if n > m then
-            Functorialisation.tm
-              (compose (n - 1) m k)
-              [ (left_base (n - 1) m k, 1); (left_filler (n - 1) m k, 1) ]
-          else if m > n then
-            Functorialisation.tm
-              (compose n (m - 1) k)
-              [ (right_base n (m - 1) k, 1); (right_filler n (m - 1) k, 1) ]
-          else
-            match n - k with
-            | i when i <= 0 -> assert false
-            | 1 -> Codim1.compose n
-            | _ ->
-                Functorialisation.tm
-                  (compose (n - 1) (m - 1) k)
-                  [
-                    (left_base (n - 1) (m - 1) k, 1);
-                    (left_filler (n - 1) (m - 1) k, 1);
-                    (right_base (n - 1) (m - 1) k, 1);
-                    (right_filler (n - 1) (m - 1) k, 1);
-                  ]
-        in
-        let ctx = Tm.ctx tm in
-        let names = Unchecked.db_level_sub_inv ctx in
-        let ctx, _, _ = Unchecked.db_levels ctx in
-        let tm = Unchecked.tm_apply_sub (Tm.develop tm) names in
-        let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" n k m in
-        let res = check_term (Ctx.check ctx) ~name:(name, 0, []) tm in
-        Hashtbl.add tbl (n, m, k) res;
-        res
-end
+    let rec compose n m k =
+      match Hashtbl.find_opt tbl (n, m, k) with
+      | Some res -> res
+      | None ->
+          let tm =
+            if n > m then
+              Functorialisation.tm
+                (compose (n - 1) m k)
+                [ (left_base (n - 1) m k, 1); (left_filler (n - 1) m k, 1) ]
+            else if m > n then
+              Functorialisation.tm
+                (compose n (m - 1) k)
+                [ (right_base n (m - 1) k, 1); (right_filler n (m - 1) k, 1) ]
+            else
+              match n - k with
+              | i when i <= 0 -> assert false
+              | 1 -> Codim1.compose n
+              | _ ->
+                  Functorialisation.tm
+                    (compose (n - 1) (m - 1) k)
+                    [
+                      (left_base (n - 1) (m - 1) k, 1);
+                      (left_filler (n - 1) (m - 1) k, 1);
+                      (right_base (n - 1) (m - 1) k, 1);
+                      (right_filler (n - 1) (m - 1) k, 1);
+                    ]
+          in
+          let ctx = Tm.ctx tm in
+          let names = Unchecked.db_level_sub_inv ctx in
+          let ctx, _, _ = Unchecked.db_levels ctx in
+          let tm = Unchecked.tm_apply_sub (Tm.develop tm) names in
+          let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" n k m in
+          let res = check_term (Ctx.check ctx) ~name:(name, 0, []) tm in
+          Hashtbl.add tbl (n, m, k) res;
+          res
+  end
 
-let compose = Composition.compose
+  let compose = Composition.compose
+end
diff --git a/lib/meta_operations/cones.mli b/lib/meta_operations/cones.mli
index bd351178..3654d633 100644
--- a/lib/meta_operations/cones.mli
+++ b/lib/meta_operations/cones.mli
@@ -1,3 +1,5 @@
-open Kernel
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val compose : int -> int -> int -> Tm.t
+  val compose : int -> int -> int -> Tm.t
+end
diff --git a/lib/meta_operations/construct.ml b/lib/meta_operations/construct.ml
index 91173f42..db7beb7f 100644
--- a/lib/meta_operations/construct.ml
+++ b/lib/meta_operations/construct.ml
@@ -1,234 +1,244 @@
 open Common
-open Kernel
-
-let to_tm (tm, _) = tm
-let to_ty (_, ty) = ty
-let characteristic_sub_ps (tm, ty) = (tm, true) :: Unchecked.ty_to_sub_ps ty
-let dim (_, ty) = Unchecked.dim_ty ty
-let arr (tm1, ty1) (tm2, _) = Arr (ty1, tm1, tm2)
-
-let rec bdry n (t, ty) =
-  match (n, ty) with
-  | 0, _ -> ((t, ty), (t, ty))
-  | 1, Arr (b, s, t) -> ((s, b), (t, b))
-  | _, Arr (b, s, _) -> bdry (n - 1) (s, b)
-  | _, _ -> assert false
-
-let coh_app coh tms =
-  let elaborate ps tms =
-    let rec aux_list psl tms =
-      match (psl, tms) with
-      | [], t :: tms -> ([ (fst t, true) ], tms, snd t)
-      | [ ps ], tms -> (
-          let s, tms, ty = aux ps tms in
-          match ty with
-          | Arr (ty, src, tgt) -> (s @ [ (tgt, false); (src, false) ], tms, ty)
-          | _ -> assert false)
-      | ps :: psl, tms -> (
-          let s, tms, _ = aux_list psl tms in
-          let sub_ps, tms, ty = aux ps tms in
-          match ty with
-          | Arr (ty, _, tgt) -> (sub_ps @ ((tgt, false) :: s), tms, ty)
-          | _ -> assert false)
-      | _ -> assert false
-    and aux ps tms = match ps with Br l -> aux_list l tms in
-    let sub_ps, _, _ = aux ps tms in
-    sub_ps
-  in
-  let ps, ty, _ = Coh.forget coh in
-  let sub = elaborate ps tms in
-  (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
-
-let of_coh coh =
-  let ps, ty, _ = Coh.forget coh in
-  let id = Unchecked.identity_ps ps in
-  (Coh (coh, id), ty)
-
-let make_sub ctx list =
-  List.map2 (fun (x, (_, b)) t -> (x, (fst t, b))) ctx list
-
-let tm_app_sub tm sub =
-  let ty = Tm.ty tm in
-  (App (tm, sub), Unchecked.ty_apply_sub ty sub)
-
-let of_tm tm =
-  let c = Tm.ctx tm in
-  tm_app_sub tm (Unchecked.identity c)
-
-let tm_app tm sub =
-  let sub = make_sub (Tm.ctx tm) sub in
-  tm_app_sub tm sub
-
-let src n t = fst (bdry n t)
-let tgt n t = snd (bdry n t)
-let wcomp = Functorialisation.wcomp
-let () = Builtin.wcomp := wcomp
-
-(* returns the n-composite of a (n+j)-cell with a (n+k)-cell *)
-let whisk3 n j k l =
-  let comp = Builtin.comp_n 3 in
-  let func_data = [ (Var.Db 6, l); (Var.Db 4, k); (Var.Db 2, j) ] in
-  let whisk = Functorialisation.coh_successively comp func_data in
-  Suspension.checked_tm (Some n) whisk
-
-let whisk3_sub_ps k t1 ty1 t2 ty2 l t3 ty3 =
-  let rec take n l =
-    match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
-  in
-  let sub_base = Unchecked.ty_to_sub_ps ty1 in
-  let sub_ext1 = take ((2 * k) + 1) (Unchecked.ty_to_sub_ps ty2) in
-  let sub_ext2 = take ((2 * l) + 1) (Unchecked.ty_to_sub_ps ty3) in
-  List.concat
-    [
-      [ (t3, true) ];
-      sub_ext2;
-      [ (t2, true) ];
-      sub_ext1;
-      [ (t1, true) ];
-      sub_base;
-    ]
-
-let wcomp3 (f, fty) n (g, gty) m (h, hty) =
-  let j = Unchecked.dim_ty fty - n - 1 in
-  let k = Unchecked.dim_ty gty - n - 1 in
-  let l = Unchecked.dim_ty hty - m - 1 in
-  let whisk = whisk3 n j k l in
-  let whisk_sub_ps = whisk3_sub_ps k f fty g gty l h hty in
-  let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-  (App (whisk, whisk_sub), Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps)
-
-let intch_comp_nm a b c =
-  let n = Unchecked.dim_ty (snd a) in
-  let m = Unchecked.dim_ty (snd c) in
-  let sub_left =
-    (fst b, true)
-    :: (fst (tgt 1 b), false)
-    :: (fst a, true)
-    :: Unchecked.ty_to_sub_ps (snd a)
-  in
-  let sub_right =
-    (fst c, true) :: Common.take m (Unchecked.ty_to_sub_ps (snd c))
-  in
-  let coh = Builtin.intch_comp_nm_coh n m in
-  let sub = sub_right @ sub_left in
-  let _, ty, _ = Coh.forget coh in
-  (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
-
-let intch_comp_mn a b c =
-  let m = Unchecked.dim_ty (snd a) in
-  let n = Unchecked.dim_ty (snd b) in
-  let sub_left = (fst a, true) :: Unchecked.ty_to_sub_ps (snd a) in
-  let sub_right =
-    (fst c, true)
-    :: (fst (tgt 1 c), false)
-    :: (fst b, true)
-    :: Common.take ((2 * n) - (2 * m) + 1) (Unchecked.ty_to_sub_ps (snd b))
-  in
-  let coh = Builtin.intch_comp_nm_coh n m in
-  let coh = Opposite.coh coh [ 1 ] in
-  let sub = sub_right @ sub_left in
-  let _, ty, _ = Coh.forget coh in
-  (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
-
-let opposite (t, ty) op_data = (Opposite.tm t op_data, Opposite.ty ty op_data)
-let inv (t, ty) = (Inverse.compute_inverse t, Inverse.ty ty)
-
-let id constr =
-  let d = dim constr in
-  ( Coh (Suspension.coh (Some d) (Builtin.id ()), characteristic_sub_ps constr),
-    arr constr constr )
-
-let rec id_n n constr =
-  match n with
-  | 0 -> constr
-  | n when n > 0 -> id (id_n (n - 1) constr)
-  | _ -> Error.fatal "call to id_n with a negative argument"
-
-let apply_sub (tm, ty) sigma =
-  (Unchecked.tm_apply_sub tm sigma, Unchecked.ty_apply_sub ty sigma)
-
-let apply_sub_ps (tm, ty) sigma =
-  (Unchecked.tm_apply_sub_ps tm sigma, Unchecked.ty_apply_sub_ps ty sigma)
-
-let rename (tm, ty) sigma =
-  (Unchecked.tm_rename tm sigma, Unchecked.ty_rename ty sigma)
-
-let inverse (tm, ty) = (Inverse.compute_inverse tm, Inverse.ty ty)
-let suspend i (tm, ty) = (Suspension.tm (Some i) tm, Suspension.ty (Some i) ty)
-
-let functorialise (tm, ty) vars =
-  (Functorialisation.tm_one_step_tm tm vars, Functorialisation.ty ty vars tm)
-
-(* TODO: more optimised implementation of this function *)
-let comp_n constrs =
-  let constrs_rev = List.rev constrs in
-  let first = function [] -> assert false | h :: _ -> h in
-  let rec glue_subs = function
-    | [ c ] -> characteristic_sub_ps c
-    | c :: constrs ->
-        (to_tm c, true) :: (to_tm (tgt 1 c), false) :: glue_subs constrs
-    | [] -> assert false
-  in
-  let l = List.length constrs in
-  let c = first constrs in
-  let d = dim c in
-  ( Coh (Suspension.coh (Some (d - 1)) (Builtin.comp_n l), glue_subs constrs_rev),
-    arr (src 1 c) (tgt 1 (first constrs_rev)) )
-
-let comp c1 c2 = comp_n [ c1; c2 ]
-let comp3 c1 c2 c3 = comp_n [ c1; c2; c3 ]
-let op dims (tm, ty) = (Opposite.tm tm dims, Opposite.ty ty dims)
-
-let drop n xs =
-  let rec aux xs counter =
-    match xs with
-    | [] -> []
-    | h :: tl -> if counter > 0 then h :: aux tl (counter - 1) else []
-  in
-  aux xs (List.length xs - n)
-
-let characteristic_sub_ps_composite constrs =
-  let rec aux = function
-    | [] -> assert false
-    | [ constr ] -> characteristic_sub_ps constr
-    | constr :: tail ->
-        [ (to_tm constr, true); (to_tm @@ tgt 1 constr, false) ] @ aux tail
-  in
-  aux @@ List.rev constrs
-
-let glue_subs_along k subs =
-  let rec aux = function
-    | [] -> assert false
-    | [ sub ] -> sub
-    | sub :: subs -> drop ((2 * k) + 1) sub @ aux subs
-  in
-  aux @@ List.rev subs
-
-let rec whisk_n n dims =
-  let l = List.length dims in
-  let comp = Builtin.comp_n l in
-  let func_data =
-    List.rev
-    @@ List.mapi (fun idx dim -> (Var.Db (2 * (idx + 1)), dim - 1)) dims
-  in
-  let whisk = Functorialisation.coh_successively comp func_data in
-  Suspension.checked_tm (Some n) whisk
-
-and wcomp_n k constrs =
-  let dims_adjusted = List.map (fun c -> dim c - k) constrs in
-  let whisk = whisk_n k dims_adjusted in
-  let whisk_sub_ps =
-    glue_subs_along k (List.map characteristic_sub_ps constrs)
-  in
-  let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-  (App (whisk, whisk_sub), Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps)
-
-let witness constr =
-  let tm = to_tm constr in
-  let d = dim constr in
-  let ty =
-    arr (wcomp constr (d - 1) (inverse constr)) (id_n 1 (src 1 constr))
-  in
-  (Inverse.compute_witness tm, ty)
-
-let develop (tm, ty) = (Unchecked.develop_tm tm, Unchecked.develop_ty ty)
+
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
+  module Opposite = Opposite.Make (Theory)
+  module Inverse = Inverse.Make (Theory)
+
+  let to_tm (tm, _) = tm
+  let to_ty (_, ty) = ty
+  let characteristic_sub_ps (tm, ty) = (tm, true) :: Unchecked.ty_to_sub_ps ty
+  let dim (_, ty) = Unchecked.dim_ty ty
+  let arr (tm1, ty1) (tm2, _) = Arr (ty1, tm1, tm2)
+
+  let rec bdry n (t, ty) =
+    match (n, ty) with
+    | 0, _ -> ((t, ty), (t, ty))
+    | 1, Arr (b, s, t) -> ((s, b), (t, b))
+    | _, Arr (b, s, _) -> bdry (n - 1) (s, b)
+    | _, _ -> assert false
+
+  let coh_app coh tms =
+    let elaborate ps tms =
+      let rec aux_list psl tms =
+        match (psl, tms) with
+        | [], t :: tms -> ([ (fst t, true) ], tms, snd t)
+        | [ ps ], tms -> (
+            let s, tms, ty = aux ps tms in
+            match ty with
+            | Arr (ty, src, tgt) -> (s @ [ (tgt, false); (src, false) ], tms, ty)
+            | _ -> assert false)
+        | ps :: psl, tms -> (
+            let s, tms, _ = aux_list psl tms in
+            let sub_ps, tms, ty = aux ps tms in
+            match ty with
+            | Arr (ty, _, tgt) -> (sub_ps @ ((tgt, false) :: s), tms, ty)
+            | _ -> assert false)
+        | _ -> assert false
+      and aux ps tms = match ps with Br l -> aux_list l tms in
+      let sub_ps, _, _ = aux ps tms in
+      sub_ps
+    in
+    let ps, ty, _ = Coh.forget coh in
+    let sub = elaborate ps tms in
+    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+
+  let of_coh coh =
+    let ps, ty, _ = Coh.forget coh in
+    let id = Unchecked.identity_ps ps in
+    (Coh (coh, id), ty)
+
+  let make_sub ctx list =
+    List.map2 (fun (x, (_, b)) t -> (x, (fst t, b))) ctx list
+
+  let tm_app_sub tm sub =
+    let ty = Tm.ty tm in
+    (App (tm, sub), Unchecked.ty_apply_sub ty sub)
+
+  let of_tm tm =
+    let c = Tm.ctx tm in
+    tm_app_sub tm (Unchecked.identity c)
+
+  let tm_app tm sub =
+    let sub = make_sub (Tm.ctx tm) sub in
+    tm_app_sub tm sub
+
+  let src n t = fst (bdry n t)
+  let tgt n t = snd (bdry n t)
+  let wcomp = Functorialisation.wcomp
+
+  (* returns the n-composite of a (n+j)-cell with a (n+k)-cell *)
+  let whisk3 n j k l =
+    let comp = Builtin.comp_n 3 in
+    let func_data = [ (Var.Db 6, l); (Var.Db 4, k); (Var.Db 2, j) ] in
+    let whisk = Functorialisation.coh_successively comp func_data in
+    Suspension.checked_tm (Some n) whisk
+
+  let whisk3_sub_ps k t1 ty1 t2 ty2 l t3 ty3 =
+    let rec take n l =
+      match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
+    in
+    let sub_base = Unchecked.ty_to_sub_ps ty1 in
+    let sub_ext1 = take ((2 * k) + 1) (Unchecked.ty_to_sub_ps ty2) in
+    let sub_ext2 = take ((2 * l) + 1) (Unchecked.ty_to_sub_ps ty3) in
+    List.concat
+      [
+        [ (t3, true) ];
+        sub_ext2;
+        [ (t2, true) ];
+        sub_ext1;
+        [ (t1, true) ];
+        sub_base;
+      ]
+
+  let wcomp3 (f, fty) n (g, gty) m (h, hty) =
+    let j = Unchecked.dim_ty fty - n - 1 in
+    let k = Unchecked.dim_ty gty - n - 1 in
+    let l = Unchecked.dim_ty hty - m - 1 in
+    let whisk = whisk3 n j k l in
+    let whisk_sub_ps = whisk3_sub_ps k f fty g gty l h hty in
+    let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
+    ( App (whisk, whisk_sub),
+      Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
+
+  let intch_comp_nm a b c =
+    let n = Unchecked.dim_ty (snd a) in
+    let m = Unchecked.dim_ty (snd c) in
+    let sub_left =
+      (fst b, true)
+      :: (fst (tgt 1 b), false)
+      :: (fst a, true)
+      :: Unchecked.ty_to_sub_ps (snd a)
+    in
+    let sub_right =
+      (fst c, true) :: Common.take m (Unchecked.ty_to_sub_ps (snd c))
+    in
+    let coh = Builtin.intch_comp_nm_coh n m in
+    let sub = sub_right @ sub_left in
+    let _, ty, _ = Coh.forget coh in
+    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+
+  let intch_comp_mn a b c =
+    let m = Unchecked.dim_ty (snd a) in
+    let n = Unchecked.dim_ty (snd b) in
+    let sub_left = (fst a, true) :: Unchecked.ty_to_sub_ps (snd a) in
+    let sub_right =
+      (fst c, true)
+      :: (fst (tgt 1 c), false)
+      :: (fst b, true)
+      :: Common.take ((2 * n) - (2 * m) + 1) (Unchecked.ty_to_sub_ps (snd b))
+    in
+    let coh = Builtin.intch_comp_nm_coh n m in
+    let coh = Opposite.coh coh [ 1 ] in
+    let sub = sub_right @ sub_left in
+    let _, ty, _ = Coh.forget coh in
+    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+
+  let opposite (t, ty) op_data = (Opposite.tm t op_data, Opposite.ty ty op_data)
+  let inv (t, ty) = (Inverse.compute_inverse t, Inverse.ty ty)
+
+  let id constr =
+    let d = dim constr in
+    ( Coh (Suspension.coh (Some d) (Builtin.id ()), characteristic_sub_ps constr),
+      arr constr constr )
+
+  let rec id_n n constr =
+    match n with
+    | 0 -> constr
+    | n when n > 0 -> id (id_n (n - 1) constr)
+    | _ -> Error.fatal "call to id_n with a negative argument"
+
+  let apply_sub (tm, ty) sigma =
+    (Unchecked.tm_apply_sub tm sigma, Unchecked.ty_apply_sub ty sigma)
+
+  let apply_sub_ps (tm, ty) sigma =
+    (Unchecked.tm_apply_sub_ps tm sigma, Unchecked.ty_apply_sub_ps ty sigma)
+
+  let rename (tm, ty) sigma =
+    (Unchecked.tm_rename tm sigma, Unchecked.ty_rename ty sigma)
+
+  let inverse (tm, ty) = (Inverse.compute_inverse tm, Inverse.ty ty)
+  let suspend i (tm, ty) = (Suspension.tm (Some i) tm, Suspension.ty (Some i) ty)
+
+  let functorialise (tm, ty) vars =
+    (Functorialisation.tm_one_step_tm tm vars, Functorialisation.ty ty vars tm)
+
+  (* TODO: more optimised implementation of this function *)
+  let comp_n constrs =
+    let constrs_rev = List.rev constrs in
+    let first = function [] -> assert false | h :: _ -> h in
+    let rec glue_subs = function
+      | [ c ] -> characteristic_sub_ps c
+      | c :: constrs ->
+          (to_tm c, true) :: (to_tm (tgt 1 c), false) :: glue_subs constrs
+      | [] -> assert false
+    in
+    let l = List.length constrs in
+    let c = first constrs in
+    let d = dim c in
+    ( Coh
+        (Suspension.coh (Some (d - 1)) (Builtin.comp_n l), glue_subs constrs_rev),
+      arr (src 1 c) (tgt 1 (first constrs_rev)) )
+
+  let comp c1 c2 = comp_n [ c1; c2 ]
+  let comp3 c1 c2 c3 = comp_n [ c1; c2; c3 ]
+  let op dims (tm, ty) = (Opposite.tm tm dims, Opposite.ty ty dims)
+
+  let drop n xs =
+    let rec aux xs counter =
+      match xs with
+      | [] -> []
+      | h :: tl -> if counter > 0 then h :: aux tl (counter - 1) else []
+    in
+    aux xs (List.length xs - n)
+
+  let characteristic_sub_ps_composite constrs =
+    let rec aux = function
+      | [] -> assert false
+      | [ constr ] -> characteristic_sub_ps constr
+      | constr :: tail ->
+          [ (to_tm constr, true); (to_tm @@ tgt 1 constr, false) ] @ aux tail
+    in
+    aux @@ List.rev constrs
+
+  let glue_subs_along k subs =
+    let rec aux = function
+      | [] -> assert false
+      | [ sub ] -> sub
+      | sub :: subs -> drop ((2 * k) + 1) sub @ aux subs
+    in
+    aux @@ List.rev subs
+
+  let rec whisk_n n dims =
+    let l = List.length dims in
+    let comp = Builtin.comp_n l in
+    let func_data =
+      List.rev
+      @@ List.mapi (fun idx dim -> (Var.Db (2 * (idx + 1)), dim - 1)) dims
+    in
+    let whisk = Functorialisation.coh_successively comp func_data in
+    Suspension.checked_tm (Some n) whisk
+
+  and wcomp_n k constrs =
+    let dims_adjusted = List.map (fun c -> dim c - k) constrs in
+    let whisk = whisk_n k dims_adjusted in
+    let whisk_sub_ps =
+      glue_subs_along k (List.map characteristic_sub_ps constrs)
+    in
+    let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
+    ( App (whisk, whisk_sub),
+      Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
+
+  let witness constr =
+    let tm = to_tm constr in
+    let d = dim constr in
+    let ty =
+      arr (wcomp constr (d - 1) (inverse constr)) (id_n 1 (src 1 constr))
+    in
+    (Inverse.compute_witness tm, ty)
+
+  let develop (tm, ty) = (Unchecked.develop_tm tm, Unchecked.develop_ty ty)
+end
diff --git a/lib/meta_operations/construct.mli b/lib/meta_operations/construct.mli
index 1b5a29c0..bc496695 100644
--- a/lib/meta_operations/construct.mli
+++ b/lib/meta_operations/construct.mli
@@ -1,40 +1,43 @@
 open Common
-open Kernel
 
-val to_tm : constr -> tm
-val to_ty : constr -> ty
-val arr : constr -> constr -> ty
-val characteristic_sub_ps : constr -> sub_ps
-val coh_app : Coh.t -> constr list -> constr
-val of_coh : Coh.t -> constr
-val make_sub : ctx -> constr list -> sub
-val tm_app_sub : Tm.t -> sub -> constr
-val tm_app : Tm.t -> constr list -> constr
-val of_tm : Tm.t -> constr
-val wcomp : constr -> int -> constr -> constr
-val wcomp3 : constr -> int -> constr -> int -> constr -> constr
-val intch_comp_nm : constr -> constr -> constr -> constr
-val intch_comp_mn : constr -> constr -> constr -> constr
-val opposite : constr -> op_data -> constr
-val inv : constr -> constr
-val functorialise : constr -> Var.t list -> constr
-val id : constr -> constr
-val id_n : int -> constr -> constr
-val dim : constr -> int
-val apply_sub : constr -> sub -> constr
-val apply_sub_ps : constr -> sub_ps -> constr
-val rename : constr -> (Var.t * tm) list -> constr
-val bdry : int -> constr -> constr * constr
-val src : int -> constr -> constr
-val tgt : int -> constr -> constr
-val inverse : constr -> constr
-val suspend : int -> constr -> constr
-val comp_n : constr list -> constr
-val comp : constr -> constr -> constr
-val comp3 : constr -> constr -> constr -> constr
-val op : int list -> constr -> constr
-val witness : constr -> constr
-val glue_subs_along : int -> 'a list list -> 'a list
-val wcomp_n : int -> constr list -> constr
-val characteristic_sub_ps_composite : constr list -> sub_ps
-val develop : constr -> constr
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
+
+  val to_tm : constr -> tm
+  val to_ty : constr -> ty
+  val arr : constr -> constr -> ty
+  val characteristic_sub_ps : constr -> sub_ps
+  val coh_app : Coh.t -> constr list -> constr
+  val of_coh : Coh.t -> constr
+  val make_sub : ctx -> constr list -> sub
+  val tm_app_sub : Tm.t -> sub -> constr
+  val tm_app : Tm.t -> constr list -> constr
+  val of_tm : Tm.t -> constr
+  val wcomp : constr -> int -> constr -> constr
+  val wcomp3 : constr -> int -> constr -> int -> constr -> constr
+  val intch_comp_nm : constr -> constr -> constr -> constr
+  val intch_comp_mn : constr -> constr -> constr -> constr
+  val opposite : constr -> op_data -> constr
+  val inv : constr -> constr
+  val functorialise : constr -> Var.t list -> constr
+  val id : constr -> constr
+  val id_n : int -> constr -> constr
+  val dim : constr -> int
+  val apply_sub : constr -> sub -> constr
+  val apply_sub_ps : constr -> sub_ps -> constr
+  val rename : constr -> (Var.t * tm) list -> constr
+  val bdry : int -> constr -> constr * constr
+  val src : int -> constr -> constr
+  val tgt : int -> constr -> constr
+  val inverse : constr -> constr
+  val suspend : int -> constr -> constr
+  val comp_n : constr list -> constr
+  val comp : constr -> constr -> constr
+  val comp3 : constr -> constr -> constr -> constr
+  val op : int list -> constr -> constr
+  val witness : constr -> constr
+  val glue_subs_along : int -> 'a list list -> 'a list
+  val wcomp_n : int -> constr list -> constr
+  val characteristic_sub_ps_composite : constr list -> sub_ps
+  val develop : constr -> constr
+end
diff --git a/lib/meta_operations/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
index 0e539424..a195dd45 100644
--- a/lib/meta_operations/cubical_composite.ml
+++ b/lib/meta_operations/cubical_composite.ml
@@ -1,417 +1,439 @@
 open Common
-open Kernel
-module F = Functorialisation
-
-module LinearComp = struct
-  module Memo = struct
-    let tbl = Hashtbl.create 24
-
-    let find arity list f =
-      try Hashtbl.find tbl (arity, list)
-      with Not_found ->
-        let res = f arity list in
-        Hashtbl.add tbl (arity, list) res;
-        res
-  end
-
-  let arity ps =
-    let d = Unchecked.dim_ps ps in
-    let rec aux ps i =
-      match (i, ps) with
-      | 0, Br l -> List.length l
-      | i, Br [ ps ] -> aux ps (i - 1)
-      | _, _ ->
-          Error.fatal "cubical composite must be on suspended linear composite"
-    in
-    aux ps (d - 1)
-
-  let tdb i = Var (Db i)
-  let tpl i = Var (Plus (Db i))
-  let tbr i = Var (Bridge (Db i))
-
-  let bcomp x y f z g =
-    let comp = Builtin.comp_n 2 in
-    let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
-    Coh (comp, sub)
 
-  let idx_src i = if i = 2 then 0 else i - 3
-  let plus i l = if List.mem (Var.Db i) l then tpl i else tdb i
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module F = Functorialisation.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Ps_reduction = Ps_reduction.Make (Theory)
+
+  module LinearComp = struct
+    module Memo = struct
+      let tbl = Hashtbl.create 24
+
+      let find arity list f =
+        try Hashtbl.find tbl (arity, list)
+        with Not_found ->
+          let res = f arity list in
+          Hashtbl.add tbl (arity, list) res;
+          res
+    end
+
+    let arity ps =
+      let d = Unchecked.dim_ps ps in
+      let rec aux ps i =
+        match (i, ps) with
+        | 0, Br l -> List.length l
+        | i, Br [ ps ] -> aux ps (i - 1)
+        | _, _ ->
+            Error.fatal
+              "cubical composite must be on suspended linear composite"
+      in
+      aux ps (d - 1)
+
+    let tdb i = Var (Db i)
+    let tpl i = Var (Plus (Db i))
+    let tbr i = Var (Bridge (Db i))
+
+    let bcomp x y f z g =
+      let comp = Builtin.comp_n 2 in
+      let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
+      Coh (comp, sub)
+
+    let idx_src i = if i = 2 then 0 else i - 3
+    let plus i l = if List.mem (Var.Db i) l then tpl i else tdb i
+
+    let src_i_f i active =
+      if active then
+        bcomp
+          (tdb (idx_src i))
+          (tdb (i - 1))
+          (tdb i)
+          (tpl (i - 1))
+          (tbr (i - 1))
+      else tdb i
+
+    let tgt_i_f i active l =
+      if active then
+        let isrc = idx_src i in
+        bcomp (tdb isrc) (tpl isrc) (tbr isrc) (plus (i - 1) l) (tpl i)
+      else Var (Plus (Db i))
+
+    let comp_biased_start arity =
+      let lin_incl =
+        let rec sub k =
+          match k with
+          | 0 -> [ (tdb 1, false) ]
+          | k -> (tdb (k + 2), k mod 2 == 0) :: sub (k - 1)
+        in
+        sub (2 * arity)
+      in
+      let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
+      bcomp (tdb 0) (tdb 1) (tdb 2) (tdb ((2 * arity) + 1)) lin_comp
+
+    let comp_biased_end arity =
+      let lin_incl = Unchecked.identity_ps (Builtin.ps_comp arity) in
+      let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
+      bcomp (tdb 0)
+        (tdb ((2 * arity) - 1))
+        lin_comp
+        (tdb ((2 * arity) + 1))
+        (tdb ((2 * arity) + 2))
+
+    let comp_biased_middle arity pos =
+      let comp = Builtin.comp_n arity in
+      let rec sub k =
+        match k with
+        | _ when k = 0 -> [ (tdb 0, false) ]
+        | _ when k < pos -> (tdb k, true) :: (tdb (k - 1), false) :: sub (k - 2)
+        | _ when k = pos + 1 ->
+            let bcomp =
+              bcomp
+                (tdb (idx_src k))
+                (tdb (k - 1))
+                (tdb k)
+                (tdb (k + 1))
+                (tdb (k + 2))
+            in
+            (bcomp, true) :: (tdb (k + 1), false) :: sub (k - 2)
+        | _ when k > pos + 1 ->
+            (tdb (k + 2), true) :: (tdb (k + 1), false) :: sub (k - 2)
+        | _ -> assert false
+      in
+      Coh (comp, sub (2 * arity))
 
-  let src_i_f i active =
-    if active then
-      bcomp (tdb (idx_src i)) (tdb (i - 1)) (tdb i) (tpl (i - 1)) (tbr (i - 1))
-    else tdb i
+    let comp_biased arity pos =
+      match pos with
+      | _ when pos = 0 -> comp_biased_start arity
+      | _ when pos = (2 * arity) + 1 -> comp_biased_end arity
+      | _ -> comp_biased_middle arity pos
 
-  let tgt_i_f i active l =
-    if active then
-      let isrc = idx_src i in
-      bcomp (tdb isrc) (tpl isrc) (tbr isrc) (plus (i - 1) l) (tpl i)
-    else Var (Plus (Db i))
+    let sub_whisk_i i arity l src tgt =
+      let rec sub k =
+        match k with
+        | k when k = 0 -> [ (tdb 0, false) ]
+        | k when k < i -> (tdb k, true) :: (tdb (k - 1), false) :: sub (k - 2)
+        | k when k = i ->
+            List.append
+              [
+                (tbr i, true);
+                (tgt, false);
+                (src, false);
+                (plus (i - 1) l, false);
+              ]
+              (sub (i - 2))
+        | k when k > i ->
+            (plus k l, true) :: (plus (k - 1) l, false) :: sub (k - 2)
+        | _ -> assert false
+      in
+      sub (2 * arity)
 
-  let comp_biased_start arity =
-    let lin_incl =
+    let sub_assc_i i arity l =
       let rec sub k =
         match k with
-        | 0 -> [ (tdb 1, false) ]
-        | k -> (tdb (k + 2), k mod 2 == 0) :: sub (k - 1)
+        | k when k = 0 && i = 0 ->
+            [ (tbr 0, true); (tpl 0, false); (tdb 0, false) ]
+        | k when k = 0 -> [ (tdb 0, false) ]
+        | k when k < i + 1 ->
+            (tdb k, true) :: (tdb (k - 1), false) :: sub (k - 2)
+        | k when k = i + 1 ->
+            List.append
+              [ (tbr i, true); (tpl i, false); (tdb k, true); (tdb i, false) ]
+              (sub (k - 2))
+        | k when k > i + 1 ->
+            (plus k l, true) :: (plus (k - 1) l, false) :: sub (k - 2)
+        | _ -> assert false
       in
       sub (2 * arity)
+
+    let assc i arity l =
+      let src = comp_biased arity (if i = 0 then 1 else i + 2) in
+      let tgt = comp_biased arity i in
+      let ps = Builtin.ps_comp (arity + 1) in
+      let assc = Coh.check_inv ps src tgt ("builtin_assc", 0, []) in
+      let sub = sub_assc_i i arity l in
+      let _, ty, _ = Coh.forget assc in
+      (Coh (assc, sub), Unchecked.ty_apply_sub_ps ty sub)
+
+    let whsk i arity l =
+      let src = src_i_f i (List.mem (Var.Db (i - 1)) l) in
+      let tgt = tgt_i_f i (List.mem (Var.Db (idx_src i)) l) l in
+      let sub = sub_whisk_i i arity l src tgt in
+      let comp = Builtin.comp_n arity in
+      let whsk = F.coh_depth0 comp [ Db i ] in
+      let _, ty, _ = Coh.forget whsk in
+      (Coh (whsk, sub), Unchecked.ty_apply_sub_ps ty sub)
+
+    let move_at v l arity =
+      let mv, ty =
+        match v with
+        | Var.Db i when i = 0 -> assc 0 arity l
+        | Var.Db i when i mod 2 = 0 -> whsk i arity l
+        | Var.Db i -> assc i arity l
+        | _ ->
+            Error.fatal
+              "cubical composite can only compute on De Bruijn variables"
+      in
+      match ty with Arr (_, s, t) -> (mv, s, t) | _ -> assert false
+
+    let build_cubical_long arity list =
+      let append_onto_if cond l1 l2 = if cond then List.append l1 l2 else l2 in
+      let rec sub ctx ?(add_src = false) onto =
+        match ctx with
+        | [] -> onto
+        | [ (v, _) ] ->
+            if List.mem v list then
+              let mv, _, tgtv = move_at v list arity in
+              (mv, true) :: (tgtv, false) :: onto
+            else onto
+        | (v, _) :: (tv, _) :: ctx ->
+            let mv, srcv, tgtv = move_at v list arity in
+            let mtv, srctv, tgttv = move_at tv list arity in
+            let src = if List.mem tv list then srctv else srcv in
+            let onto =
+              append_onto_if (List.mem v list)
+                [ (mv, true); (tgtv, false) ]
+                (append_onto_if (List.mem tv list)
+                   [ (mtv, true); (tgttv, false) ]
+                   (append_onto_if add_src [ (src, false) ] onto))
+            in
+            sub ctx onto
+      in
+      let comp = Suspension.coh (Some 1) (Builtin.comp_n (List.length list)) in
+      let base = [ (plus ((2 * arity) - 1) list, false); (tdb 0, false) ] in
+      let ctx_comp = Unchecked.ps_to_ctx (Builtin.ps_comp arity) in
+      let s = sub ctx_comp ~add_src:true base in
+      let _, ty, _ = Coh.forget comp in
+      (Coh (comp, s), Unchecked.ty_apply_sub_ps ty s)
+
+    let build_cubical arity list =
+      match arity with
+      | 1 ->
+          let src_on = List.mem (Var.Db 1) list in
+          let tgt_on = List.mem (Var.Db 0) list in
+          (tbr 2, Arr (Obj, src_i_f 2 src_on, tgt_i_f 2 tgt_on list))
+      | arity -> build_cubical_long arity list
+
+    let cubical arity list = Memo.find arity list build_cubical
+  end
+
+  let desuspend_db v d =
+    match v with
+    | Var.Db i -> Var.Db (i - (2 * d))
+    | _ -> Error.fatal "only de Bruijn levels expected in coherences"
+
+  (* source and source inclusion of a functorialised ps *)
+  let ctx_src ps l =
+    let d = Unchecked.dim_ps ps in
+    let bdry = Unchecked.ps_bdry ps in
+    let tgt_incl_ps = Unchecked.ps_tgt ps in
+    let tgt_f, bdry_f, names, l = F.sub_w_tgt bdry tgt_incl_ps l in
+    let src_ctx, i1, i2 = Unchecked.ps_compose (d - 1) ps bdry_f in
+    let in_minus = Unchecked.identity_ps ps in
+    let src_incl = Unchecked.pullback_up (d - 1) ps bdry_f in_minus tgt_f in
+    (src_ctx, src_incl, i1, i2, bdry_f, l, names)
+
+  (* target and target inclusion of a functorialised ps *)
+  let ctx_tgt ps l =
+    let d = Unchecked.dim_ps ps in
+    let bdry = Unchecked.ps_bdry ps in
+    let src_incl_ps = Unchecked.ps_src ps in
+    let src_f, bdry_f, names, l_bdry = F.sub_w_tgt bdry src_incl_ps l in
+    let tgt_ctx, i1, i2 = Unchecked.ps_compose (d - 1) bdry_f ps in
+    let id = Unchecked.identity_ps ps in
+    let in_plus = Unchecked.sub_ps_rename id (F.tgt_renaming l) in
+    let tgt_incl = Unchecked.pullback_up (d - 1) bdry_f ps src_f in_plus in
+    (tgt_ctx, tgt_incl, i1, i2, bdry_f, l_bdry, names)
+
+  (* Construct source (t[i1]) * (tgt_f[i2]) *)
+  let naturality_src coh ty tgt ty_base dim l i1 i2 names =
+    let t = Coh (coh, i1) in
+    if l = [] then t
+    else
+      let tgt_f_ty = Unchecked.rename_ty (F.ty ty_base l tgt) names in
+      let tgt_f_ty = Unchecked.ty_apply_sub_ps tgt_f_ty i2 in
+      let tgt_f = Unchecked.rename_tm (F.tm_one_step_tm tgt l) names in
+      let tgt_f = Unchecked.tm_apply_sub_ps tgt_f i2 in
+      let ty = Unchecked.ty_apply_sub_ps ty i1 in
+      let coh_src_sub_ps = F.whisk_sub_ps 0 t ty tgt_f tgt_f_ty in
+      let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
+      Coh (comp, coh_src_sub_ps)
+
+  (* Construct target (src_f[i1]) * (t[i2]) *)
+  let naturality_tgt coh ty src ty_base dim l i1 i2 names =
+    let t = Coh (coh, i2) in
+    if l = [] then t
+    else
+      let src_f_ty = Unchecked.rename_ty (F.ty ty_base l src) names in
+      let src_f_ty = Unchecked.ty_apply_sub_ps src_f_ty i1 in
+      let src_f = Unchecked.rename_tm (F.tm_one_step_tm src l) names in
+      let src_f = Unchecked.tm_apply_sub_ps src_f i1 in
+      let ty = Unchecked.ty_apply_sub_ps ty i2 in
+      let coh_tgt_sub_ps = F.whisk_sub_ps 0 src_f src_f_ty t ty in
+      let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
+      Coh (comp, coh_tgt_sub_ps)
+
+  let biasor_sub_intch_src ps bdry_f i1 i2 d =
+    let ps_red = Ps_reduction.reduce (d - 1) ps in
+    let prod, _, _ = Unchecked.ps_compose (d - 1) ps_red bdry_f in
+    let red_sub_prod = Ps_reduction.reduction_sub prod in
+    let red_sub_ps = Ps_reduction.reduction_sub ps in
+    let left_leg = Unchecked.sub_ps_apply_sub_ps red_sub_ps i1 in
+    let prod_to_src = Unchecked.pullback_up (d - 1) ps_red bdry_f left_leg i2 in
+    Unchecked.sub_ps_apply_sub_ps red_sub_prod prod_to_src
+
+  let biasor_sub_intch_tgt ps bdry_f i1 i2 d =
+    let ps_red = Ps_reduction.reduce (d - 1) ps in
+    let prod, _, _ = Unchecked.ps_compose (d - 1) bdry_f ps_red in
+    let red_sub_prod = Ps_reduction.reduction_sub prod in
+    let red_sub_ps = Ps_reduction.reduction_sub ps in
+    let right_leg = Unchecked.sub_ps_apply_sub_ps red_sub_ps i2 in
+    let prod_to_src =
+      Unchecked.pullback_up (d - 1) bdry_f ps_red i1 right_leg
     in
-    let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
-    bcomp (tdb 0) (tdb 1) (tdb 2) (tdb ((2 * arity) + 1)) lin_comp
-
-  let comp_biased_end arity =
-    let lin_incl = Unchecked.identity_ps (Builtin.ps_comp arity) in
-    let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
-    bcomp (tdb 0)
-      (tdb ((2 * arity) - 1))
-      lin_comp
-      (tdb ((2 * arity) + 1))
-      (tdb ((2 * arity) + 2))
-
-  let comp_biased_middle arity pos =
-    let comp = Builtin.comp_n arity in
-    let rec sub k =
-      match k with
-      | _ when k = 0 -> [ (tdb 0, false) ]
-      | _ when k < pos -> (tdb k, true) :: (tdb (k - 1), false) :: sub (k - 2)
-      | _ when k = pos + 1 ->
-          let bcomp =
-            bcomp
-              (tdb (idx_src k))
-              (tdb (k - 1))
-              (tdb k)
-              (tdb (k + 1))
-              (tdb (k + 2))
-          in
-          (bcomp, true) :: (tdb (k + 1), false) :: sub (k - 2)
-      | _ when k > pos + 1 ->
-          (tdb (k + 2), true) :: (tdb (k + 1), false) :: sub (k - 2)
-      | _ -> assert false
-    in
-    Coh (comp, sub (2 * arity))
-
-  let comp_biased arity pos =
-    match pos with
-    | _ when pos = 0 -> comp_biased_start arity
-    | _ when pos = (2 * arity) + 1 -> comp_biased_end arity
-    | _ -> comp_biased_middle arity pos
-
-  let sub_whisk_i i arity l src tgt =
-    let rec sub k =
-      match k with
-      | k when k = 0 -> [ (tdb 0, false) ]
-      | k when k < i -> (tdb k, true) :: (tdb (k - 1), false) :: sub (k - 2)
-      | k when k = i ->
-          List.append
-            [
-              (tbr i, true); (tgt, false); (src, false); (plus (i - 1) l, false);
-            ]
-            (sub (i - 2))
-      | k when k > i ->
-          (plus k l, true) :: (plus (k - 1) l, false) :: sub (k - 2)
-      | _ -> assert false
-    in
-    sub (2 * arity)
-
-  let sub_assc_i i arity l =
-    let rec sub k =
-      match k with
-      | k when k = 0 && i = 0 ->
-          [ (tbr 0, true); (tpl 0, false); (tdb 0, false) ]
-      | k when k = 0 -> [ (tdb 0, false) ]
-      | k when k < i + 1 -> (tdb k, true) :: (tdb (k - 1), false) :: sub (k - 2)
-      | k when k = i + 1 ->
-          List.append
-            [ (tbr i, true); (tpl i, false); (tdb k, true); (tdb i, false) ]
-            (sub (k - 2))
-      | k when k > i + 1 ->
-          (plus k l, true) :: (plus (k - 1) l, false) :: sub (k - 2)
-      | _ -> assert false
-    in
-    sub (2 * arity)
-
-  let assc i arity l =
-    let src = comp_biased arity (if i = 0 then 1 else i + 2) in
-    let tgt = comp_biased arity i in
-    let ps = Builtin.ps_comp (arity + 1) in
-    let assc = Coh.check_inv ps src tgt ("builtin_assc", 0, []) in
-    let sub = sub_assc_i i arity l in
-    let _, ty, _ = Coh.forget assc in
-    (Coh (assc, sub), Unchecked.ty_apply_sub_ps ty sub)
-
-  let whsk i arity l =
-    let src = src_i_f i (List.mem (Var.Db (i - 1)) l) in
-    let tgt = tgt_i_f i (List.mem (Var.Db (idx_src i)) l) l in
-    let sub = sub_whisk_i i arity l src tgt in
-    let comp = Builtin.comp_n arity in
-    let whsk = F.coh_depth0 comp [ Db i ] in
-    let _, ty, _ = Coh.forget whsk in
-    (Coh (whsk, sub), Unchecked.ty_apply_sub_ps ty sub)
-
-  let move_at v l arity =
-    let mv, ty =
-      match v with
-      | Var.Db i when i = 0 -> assc 0 arity l
-      | Var.Db i when i mod 2 = 0 -> whsk i arity l
-      | Var.Db i -> assc i arity l
-      | _ ->
-          Error.fatal
-            "cubical composite can only compute on De Bruijn variables"
-    in
-    match ty with Arr (_, s, t) -> (mv, s, t) | _ -> assert false
-
-  let build_cubical_long arity list =
-    let append_onto_if cond l1 l2 = if cond then List.append l1 l2 else l2 in
-    let rec sub ctx ?(add_src = false) onto =
-      match ctx with
-      | [] -> onto
-      | [ (v, _) ] ->
-          if List.mem v list then
-            let mv, _, tgtv = move_at v list arity in
-            (mv, true) :: (tgtv, false) :: onto
-          else onto
-      | (v, _) :: (tv, _) :: ctx ->
-          let mv, srcv, tgtv = move_at v list arity in
-          let mtv, srctv, tgttv = move_at tv list arity in
-          let src = if List.mem tv list then srctv else srcv in
-          let onto =
-            append_onto_if (List.mem v list)
-              [ (mv, true); (tgtv, false) ]
-              (append_onto_if (List.mem tv list)
-                 [ (mtv, true); (tgttv, false) ]
-                 (append_onto_if add_src [ (src, false) ] onto))
-          in
-          sub ctx onto
-    in
-    let comp = Suspension.coh (Some 1) (Builtin.comp_n (List.length list)) in
-    let base = [ (plus ((2 * arity) - 1) list, false); (tdb 0, false) ] in
-    let ctx_comp = Unchecked.ps_to_ctx (Builtin.ps_comp arity) in
-    let s = sub ctx_comp ~add_src:true base in
-    let _, ty, _ = Coh.forget comp in
-    (Coh (comp, s), Unchecked.ty_apply_sub_ps ty s)
-
-  let build_cubical arity list =
-    match arity with
-    | 1 ->
-        let src_on = List.mem (Var.Db 1) list in
-        let tgt_on = List.mem (Var.Db 0) list in
-        (tbr 2, Arr (Obj, src_i_f 2 src_on, tgt_i_f 2 tgt_on list))
-    | arity -> build_cubical_long arity list
-
-  let cubical arity list = Memo.find arity list build_cubical
-end
+    Unchecked.sub_ps_apply_sub_ps red_sub_prod prod_to_src
 
-let desuspend_db v d =
-  match v with
-  | Var.Db i -> Var.Db (i - (2 * d))
-  | _ -> Error.fatal "only de Bruijn levels expected in coherences"
-
-(* source and source inclusion of a functorialised ps *)
-let ctx_src ps l =
-  let d = Unchecked.dim_ps ps in
-  let bdry = Unchecked.ps_bdry ps in
-  let tgt_incl_ps = Unchecked.ps_tgt ps in
-  let tgt_f, bdry_f, names, l = F.sub_w_tgt bdry tgt_incl_ps l in
-  let src_ctx, i1, i2 = Unchecked.ps_compose (d - 1) ps bdry_f in
-  let in_minus = Unchecked.identity_ps ps in
-  let src_incl = Unchecked.pullback_up (d - 1) ps bdry_f in_minus tgt_f in
-  (src_ctx, src_incl, i1, i2, bdry_f, l, names)
-
-(* target and target inclusion of a functorialised ps *)
-let ctx_tgt ps l =
-  let d = Unchecked.dim_ps ps in
-  let bdry = Unchecked.ps_bdry ps in
-  let src_incl_ps = Unchecked.ps_src ps in
-  let src_f, bdry_f, names, l_bdry = F.sub_w_tgt bdry src_incl_ps l in
-  let tgt_ctx, i1, i2 = Unchecked.ps_compose (d - 1) bdry_f ps in
-  let id = Unchecked.identity_ps ps in
-  let in_plus = Unchecked.sub_ps_rename id (F.tgt_renaming l) in
-  let tgt_incl = Unchecked.pullback_up (d - 1) bdry_f ps src_f in_plus in
-  (tgt_ctx, tgt_incl, i1, i2, bdry_f, l_bdry, names)
-
-(* Construct source (t[i1]) * (tgt_f[i2]) *)
-let naturality_src coh ty tgt ty_base dim l i1 i2 names =
-  let t = Coh (coh, i1) in
-  if l = [] then t
-  else
-    let tgt_f_ty = Unchecked.rename_ty (F.ty ty_base l tgt) names in
-    let tgt_f_ty = Unchecked.ty_apply_sub_ps tgt_f_ty i2 in
-    let tgt_f = Unchecked.rename_tm (F.tm_one_step_tm tgt l) names in
-    let tgt_f = Unchecked.tm_apply_sub_ps tgt_f i2 in
-    let ty = Unchecked.ty_apply_sub_ps ty i1 in
-    let coh_src_sub_ps = F.whisk_sub_ps 0 t ty tgt_f tgt_f_ty in
-    let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
-    Coh (comp, coh_src_sub_ps)
-
-(* Construct target (src_f[i1]) * (t[i2]) *)
-let naturality_tgt coh ty src ty_base dim l i1 i2 names =
-  let t = Coh (coh, i2) in
-  if l = [] then t
-  else
-    let src_f_ty = Unchecked.rename_ty (F.ty ty_base l src) names in
-    let src_f_ty = Unchecked.ty_apply_sub_ps src_f_ty i1 in
-    let src_f = Unchecked.rename_tm (F.tm_one_step_tm src l) names in
-    let src_f = Unchecked.tm_apply_sub_ps src_f i1 in
-    let ty = Unchecked.ty_apply_sub_ps ty i2 in
-    let coh_tgt_sub_ps = F.whisk_sub_ps 0 src_f src_f_ty t ty in
-    let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
-    Coh (comp, coh_tgt_sub_ps)
-
-let biasor_sub_intch_src ps bdry_f i1 i2 d =
-  let ps_red = Ps_reduction.reduce (d - 1) ps in
-  let prod, _, _ = Unchecked.ps_compose (d - 1) ps_red bdry_f in
-  let red_sub_prod = Ps_reduction.reduction_sub prod in
-  let red_sub_ps = Ps_reduction.reduction_sub ps in
-  let left_leg = Unchecked.sub_ps_apply_sub_ps red_sub_ps i1 in
-  let prod_to_src = Unchecked.pullback_up (d - 1) ps_red bdry_f left_leg i2 in
-  Unchecked.sub_ps_apply_sub_ps red_sub_prod prod_to_src
-
-let biasor_sub_intch_tgt ps bdry_f i1 i2 d =
-  let ps_red = Ps_reduction.reduce (d - 1) ps in
-  let prod, _, _ = Unchecked.ps_compose (d - 1) bdry_f ps_red in
-  let red_sub_prod = Ps_reduction.reduction_sub prod in
-  let red_sub_ps = Ps_reduction.reduction_sub ps in
-  let right_leg = Unchecked.sub_ps_apply_sub_ps red_sub_ps i2 in
-  let prod_to_src = Unchecked.pullback_up (d - 1) bdry_f ps_red i1 right_leg in
-  Unchecked.sub_ps_apply_sub_ps red_sub_prod prod_to_src
-
-(* Interchange needed for source of depth-1 non-inv coh *)
-(*
+  (* Interchange needed for source of depth-1 non-inv coh *)
+  (*
 https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVycmlnaHRhcnJvd3tcXHBhcnRpYWxcXEdhbW1hfV57WF9cXHRhdX0iXSxbMCwzLCJcXEdhbW1hIl0sWzAsMSwiXFxHYW1tYV57cmVkfSJdLFsxLDIsIlxcRGVsdGEiXSxbMSwzLCJcXFBoaSJdLFszLDIsIlxcRGVsdGFee3JlZH0iXSxbMSw0LCJcXG92ZXJyaWdodGFycm93e1xcR2FtbWF9XlgiXSxbMCwxLCJcXHNpZ21hIl0sWzAsMiwiXFx0YXUiLDEseyJsYWJlbF9wb3NpdGlvbiI6NzAsImN1cnZlIjo1fV0sWzMsMiwiXFxyaG9fXFxHYW1tYSIsMl0sWzAsMywiXFx0YXVfciIsMV0sWzEsNCwial8yIiwxXSxbMyw0LCJqXzEiLDFdLFs0LDAsIiIsMCx7InN0eWxlIjp7Im5hbWUiOiJjb3JuZXIifX1dLFs0LDUsIiIsMCx7InN0eWxlIjp7ImJvZHkiOnsibmFtZSI6ImRhc2hlZCJ9fX1dLFsyLDUsImlfMSIsMV0sWzEsNSwiaV8yIiwxXSxbNSwwLCIiLDEseyJzdHlsZSI6eyJuYW1lIjoiY29ybmVyIn19XSxbNiw0LCJcXHJob19cXERlbHRhIiwxLHsiY3VydmUiOjF9XSxbMiw3XSxbMSw3LCJcXG92ZXJyaWdodGFycm93e1xcdGF1fV5YIiwxLHsiY3VydmUiOi0zfV0sWzUsNywiIiwxLHsic3R5bGUiOnsiYm9keSI6eyJuYW1lIjoiZGFzaGVkIn19fV1d
  *)
-let depth1_interchanger_src coh coh_bridge l =
-  let gamma, coh_ty, _ = Coh.forget coh in
-  let _, tgt, ty_base = Coh.noninv_srctgt coh in
-  let d = Unchecked.dim_ps gamma in
-  let src_ctx, src_incl, i1, i2, bdry_f, l_tgt, names = ctx_src gamma l in
-  let coh_src = naturality_src coh coh_ty tgt ty_base d l_tgt i1 i2 names in
-  let coh_tgt = Coh (coh_bridge, biasor_sub_intch_src gamma bdry_f i1 i2 d) in
-  let intch_coh = Coh.check_inv src_ctx coh_src coh_tgt ("intch_src", 0, []) in
-  let _, ty, _ = Coh.forget intch_coh in
-  let intch = Coh (intch_coh, src_incl) in
-  let ty = Unchecked.ty_apply_sub_ps ty src_incl in
-  (intch, ty)
-
-let depth1_interchanger_tgt coh coh_bridge l =
-  let gamma, coh_ty, _ = Coh.forget coh in
-  let src, _, ty_base = Coh.noninv_srctgt coh in
-  let d = Unchecked.dim_ps gamma in
-  let tgt_ctx, tgt_incl, i1, i2, bdry_f, l_src, names = ctx_tgt gamma l in
-  let coh_tgt = naturality_tgt coh coh_ty src ty_base d l_src i1 i2 names in
-  let coh_src = Coh (coh_bridge, biasor_sub_intch_tgt gamma bdry_f i1 i2 d) in
-  let intch_coh = Coh.check_inv tgt_ctx coh_src coh_tgt ("intch_tgt", 0, []) in
-  let _, ty, _ = Coh.forget intch_coh in
-  let intch = Coh (intch_coh, tgt_incl) in
-  let ty = Unchecked.ty_apply_sub_ps ty tgt_incl in
-  (intch, ty)
-
-(*
+  let depth1_interchanger_src coh coh_bridge l =
+    let gamma, coh_ty, _ = Coh.forget coh in
+    let _, tgt, ty_base = Coh.noninv_srctgt coh in
+    let d = Unchecked.dim_ps gamma in
+    let src_ctx, src_incl, i1, i2, bdry_f, l_tgt, names = ctx_src gamma l in
+    let coh_src = naturality_src coh coh_ty tgt ty_base d l_tgt i1 i2 names in
+    let coh_tgt = Coh (coh_bridge, biasor_sub_intch_src gamma bdry_f i1 i2 d) in
+    let intch_coh =
+      Coh.check_inv src_ctx coh_src coh_tgt ("intch_src", 0, [])
+    in
+    let _, ty, _ = Coh.forget intch_coh in
+    let intch = Coh (intch_coh, src_incl) in
+    let ty = Unchecked.ty_apply_sub_ps ty src_incl in
+    (intch, ty)
+
+  let depth1_interchanger_tgt coh coh_bridge l =
+    let gamma, coh_ty, _ = Coh.forget coh in
+    let src, _, ty_base = Coh.noninv_srctgt coh in
+    let d = Unchecked.dim_ps gamma in
+    let tgt_ctx, tgt_incl, i1, i2, bdry_f, l_src, names = ctx_tgt gamma l in
+    let coh_tgt = naturality_tgt coh coh_ty src ty_base d l_src i1 i2 names in
+    let coh_src = Coh (coh_bridge, biasor_sub_intch_tgt gamma bdry_f i1 i2 d) in
+    let intch_coh =
+      Coh.check_inv tgt_ctx coh_src coh_tgt ("intch_tgt", 0, [])
+    in
+    let _, ty, _ = Coh.forget intch_coh in
+    let intch = Coh (intch_coh, tgt_incl) in
+    let ty = Unchecked.ty_apply_sub_ps ty tgt_incl in
+    (intch, ty)
+
+  (*
   Compare substitutions out of the same ps-context
   and fill gaps between matching but different terms with
   the correct cubical composite
  *)
-let depth1_bridge_sub ps_inter l_inter d =
-  let rec aux red =
-    match red with
-    | [] -> []
-    | (t, true) :: (w, false) :: red ->
-        let ps_comp, s =
-          match t with
-          | Coh (comp, s) ->
-              let ps_comp, _, _ = Coh.forget comp in
-              (ps_comp, s)
-          | Var v ->
-              let ty, _ = List.assoc v (Unchecked.ps_to_ctx ps_inter) in
-              let s = (Var v, true) :: Unchecked.ty_to_sub_ps ty in
-              let ps_comp =
-                Suspension.ps (Some (Unchecked.dim_ty ty)) (Br [])
-              in
-              (ps_comp, s)
-          | App _ -> assert false
-          | Meta_tm _ -> Error.fatal "meta_variables must have been resolved"
-        in
-        let l = F.preimage (Unchecked.ps_to_ctx ps_comp) s l_inter in
-        if l <> [] then
-          let arity = LinearComp.arity ps_comp in
-          let s = F.sub (Unchecked.sub_ps_to_sub s) l in
-          let w_plus = Unchecked.tm_rename w (F.tgt_renaming l_inter) in
-          let list = List.map (fun v -> desuspend_db v (d - 1)) l in
-          let ccomp, ty = LinearComp.cubical arity list in
-          let ccomp = Suspension.tm (Some (d - 1)) ccomp in
-          let ccomp = Unchecked.tm_apply_sub ccomp s in
-          let ty = Suspension.ty (Some (d - 1)) ty in
-          let ty = Unchecked.ty_apply_sub ty s in
-          let src, tgt =
-            match ty with Arr (_, s, t) -> (s, t) | _ -> assert false
+  let depth1_bridge_sub ps_inter l_inter d =
+    let rec aux red =
+      match red with
+      | [] -> []
+      | (t, true) :: (w, false) :: red ->
+          let ps_comp, s =
+            match t with
+            | Coh (comp, s) ->
+                let ps_comp, _, _ = Coh.forget comp in
+                (ps_comp, s)
+            | Var v ->
+                let ty, _ = List.assoc v (Unchecked.ps_to_ctx ps_inter) in
+                let s = (Var v, true) :: Unchecked.ty_to_sub_ps ty in
+                let ps_comp =
+                  Suspension.ps (Some (Unchecked.dim_ty ty)) (Br [])
+                in
+                (ps_comp, s)
+            | App _ -> assert false
+            | Meta_tm _ -> Error.fatal "meta_variables must have been resolved"
           in
-          (ccomp, true) :: (tgt, false) :: (src, false) :: (w_plus, false)
-          :: aux red
-        else (t, true) :: (w, false) :: aux red
-    | (t, e) :: red -> (t, e) :: aux red
-  in
-  aux (Ps_reduction.reduction_sub ps_inter)
-
-let loc_max_dim d ps x =
-  let ctx = Unchecked.ps_to_ctx ps in
-  let ty, expl = List.assoc x ctx in
-  expl && Unchecked.dim_ty ty = d
-
-let intermediate_ps ps l d =
-  let l_d0, l_d1 = List.partition (loc_max_dim (d - 1) ps) l in
-  if l_d0 = [] then (ps, l, Unchecked.(sub_ps_to_sub (identity_ps ps)))
-  else
-    let ps_f_c = F.ctx (Unchecked.ps_to_ctx ps) l_d0 in
-    let _, names, _ = Unchecked.db_levels ps_f_c in
-    let ps_f = PS.(forget (mk (Ctx.check ps_f_c))) in
-    let l_psf = List.map (fun x -> Var.Db (fst (List.assoc x names))) l_d1 in
-    let names = List.map (fun (x, (n, e)) -> (Var.Db n, (Var x, e))) names in
-    (ps_f, l_psf, names)
-
-let bridge_ps ps_inter l_inter d =
-  let red_sub = Ps_reduction.reduction_sub ps_inter in
-  let ps_red = Ps_reduction.reduce (d - 1) ps_inter in
-  let ps_red_c = Unchecked.ps_to_ctx ps_red in
-  let coh_l = F.preimage ps_red_c red_sub l_inter in
-  let coh_l = List.filter (loc_max_dim d ps_red) coh_l in
-  (ps_red, coh_l)
-
-let bridge_coh coh ps_bridge =
-  let _, _, name = Coh.forget coh in
-  let src, tgt, _ = Coh.noninv_srctgt coh in
-  let name_red = (Printing.full_name name ^ "_red", 0, []) in
-  let coh_bridge = Coh.check_noninv ps_bridge src tgt name_red in
-  coh_bridge
-
-let coh_depth1 coh l =
-  let ps, _, pp_data = Coh.forget coh in
-  let d = Unchecked.dim_ps ps in
-  let ps_inter, l_inter, names = intermediate_ps ps l d in
-  let ps_bridge, l_bridge = bridge_ps ps_inter l_inter d in
-  let coh_bridge = bridge_coh coh ps_bridge in
-  let intch_src, intch_src_ty = depth1_interchanger_src coh coh_bridge l in
-  let intch_tgt, intch_tgt_ty = depth1_interchanger_tgt coh coh_bridge l in
-  let bridge = depth1_bridge_sub ps_inter l_inter d in
-  let bridge = Unchecked.sub_ps_apply_sub bridge (F.sub names l_inter) in
-  let coh_bridge_f = F.coh_depth0 coh_bridge l_bridge in
-  let middle = Coh (coh_bridge_f, bridge) in
-  let inner_tgt, final_tgt =
-    match intch_tgt_ty with Arr (_, t, t') -> (t, t') | _ -> assert false
-  in
-  let comp_sub_ps =
-    List.append
-      [
-        (intch_tgt, true);
-        (final_tgt, false);
-        (middle, true);
-        (inner_tgt, false);
-        (intch_src, true);
-      ]
-      (Unchecked.ty_to_sub_ps intch_src_ty)
-  in
-  let comp = Suspension.coh (Some d) (Builtin.comp_n 3) in
-  let ctx = F.ctx (Unchecked.ps_to_ctx ps) l in
-  let name = F.pp_data l pp_data in
-  check_term (Ctx.check ctx) ~name (Coh (comp, comp_sub_ps))
-
-let init () = F.coh_depth1 := coh_depth1
+          let l = F.preimage (Unchecked.ps_to_ctx ps_comp) s l_inter in
+          if l <> [] then
+            let arity = LinearComp.arity ps_comp in
+            let s = F.sub (Unchecked.sub_ps_to_sub s) l in
+            let w_plus = Unchecked.tm_rename w (F.tgt_renaming l_inter) in
+            let list = List.map (fun v -> desuspend_db v (d - 1)) l in
+            let ccomp, ty = LinearComp.cubical arity list in
+            let ccomp = Suspension.tm (Some (d - 1)) ccomp in
+            let ccomp = Unchecked.tm_apply_sub ccomp s in
+            let ty = Suspension.ty (Some (d - 1)) ty in
+            let ty = Unchecked.ty_apply_sub ty s in
+            let src, tgt =
+              match ty with Arr (_, s, t) -> (s, t) | _ -> assert false
+            in
+            (ccomp, true) :: (tgt, false) :: (src, false) :: (w_plus, false)
+            :: aux red
+          else (t, true) :: (w, false) :: aux red
+      | (t, e) :: red -> (t, e) :: aux red
+    in
+    aux (Ps_reduction.reduction_sub ps_inter)
+
+  let loc_max_dim d ps x =
+    let ctx = Unchecked.ps_to_ctx ps in
+    let ty, expl = List.assoc x ctx in
+    expl && Unchecked.dim_ty ty = d
+
+  let intermediate_ps ps l d =
+    let l_d0, l_d1 = List.partition (loc_max_dim (d - 1) ps) l in
+    if l_d0 = [] then (ps, l, Unchecked.(sub_ps_to_sub (identity_ps ps)))
+    else
+      let ps_f_c = F.ctx (Unchecked.ps_to_ctx ps) l_d0 in
+      let _, names, _ = Unchecked.db_levels ps_f_c in
+      let ps_f = PS.(forget (mk (Ctx.check ps_f_c))) in
+      let l_psf = List.map (fun x -> Var.Db (fst (List.assoc x names))) l_d1 in
+      let names = List.map (fun (x, (n, e)) -> (Var.Db n, (Var x, e))) names in
+      (ps_f, l_psf, names)
+
+  let bridge_ps ps_inter l_inter d =
+    let red_sub = Ps_reduction.reduction_sub ps_inter in
+    let ps_red = Ps_reduction.reduce (d - 1) ps_inter in
+    let ps_red_c = Unchecked.ps_to_ctx ps_red in
+    let coh_l = F.preimage ps_red_c red_sub l_inter in
+    let coh_l = List.filter (loc_max_dim d ps_red) coh_l in
+    (ps_red, coh_l)
+
+  let bridge_coh coh ps_bridge =
+    let _, _, name = Coh.forget coh in
+    let src, tgt, _ = Coh.noninv_srctgt coh in
+    let name_red = (Printing.full_name name ^ "_red", 0, []) in
+    let coh_bridge = Coh.check_noninv ps_bridge src tgt name_red in
+    coh_bridge
+
+  let coh_depth1 coh l =
+    let ps, _, pp_data = Coh.forget coh in
+    let d = Unchecked.dim_ps ps in
+    let ps_inter, l_inter, names = intermediate_ps ps l d in
+    let ps_bridge, l_bridge = bridge_ps ps_inter l_inter d in
+    let coh_bridge = bridge_coh coh ps_bridge in
+    let intch_src, intch_src_ty = depth1_interchanger_src coh coh_bridge l in
+    let intch_tgt, intch_tgt_ty = depth1_interchanger_tgt coh coh_bridge l in
+    let bridge = depth1_bridge_sub ps_inter l_inter d in
+    let bridge = Unchecked.sub_ps_apply_sub bridge (F.sub names l_inter) in
+    let coh_bridge_f = F.coh_depth0 coh_bridge l_bridge in
+    let middle = Coh (coh_bridge_f, bridge) in
+    let inner_tgt, final_tgt =
+      match intch_tgt_ty with Arr (_, t, t') -> (t, t') | _ -> assert false
+    in
+    let comp_sub_ps =
+      List.append
+        [
+          (intch_tgt, true);
+          (final_tgt, false);
+          (middle, true);
+          (inner_tgt, false);
+          (intch_src, true);
+        ]
+        (Unchecked.ty_to_sub_ps intch_src_ty)
+    in
+    let comp = Suspension.coh (Some d) (Builtin.comp_n 3) in
+    let ctx = F.ctx (Unchecked.ps_to_ctx ps) l in
+    let name = F.pp_data l pp_data in
+    check_term (Ctx.check ctx) ~name (Coh (comp, comp_sub_ps))
+
+  let init () = F.coh_depth1 := coh_depth1
+end
diff --git a/lib/meta_operations/cubical_composite.mli b/lib/meta_operations/cubical_composite.mli
index 28ead8dc..8f3a2bab 100644
--- a/lib/meta_operations/cubical_composite.mli
+++ b/lib/meta_operations/cubical_composite.mli
@@ -1 +1,3 @@
-val init : unit -> unit
+module Make (_ : Theory.S) : sig
+  val init : unit -> unit
+end
diff --git a/lib/meta_operations/cylinders.ml b/lib/meta_operations/cylinders.ml
index 4e9b69a0..7dcc132b 100644
--- a/lib/meta_operations/cylinders.ml
+++ b/lib/meta_operations/cylinders.ml
@@ -1,623 +1,658 @@
 open Common
-open Kernel
-
-let wcomp = Construct.wcomp
-
-(* Cylinder contexts *)
-module Cylinder = struct
-  let tbl = Hashtbl.create 97
-
-  let rec ctx n =
-    match Hashtbl.find_opt tbl n with
-    | Some res -> res
-    | None ->
-        let res =
-          match n with
-          | n when n <= 0 ->
-              ( Unchecked.ps_to_ctx (Br []),
-                Var.Db 0,
-                Var.Db 0,
-                Var.Db 0,
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ],
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ] )
-          | 1 ->
-              ( Unchecked.ps_to_ctx (Br [ Br [] ]),
-                Var.Db 0,
-                Var.Db 1,
-                Var.Db 2,
-                [ (Var.Db 0, (Var (Var.Db 0), true)) ],
-                [ (Var.Db 0, (Var (Var.Db 1), true)) ] )
-          | n ->
-              let ctx, lb, ub, f, _, _ = ctx (n - 1) in
-              let id = Unchecked.identity ctx in
-              let ctx = Functorialisation.ctx ctx [ lb; ub; f ] in
-              let names = Unchecked.db_level_sub_inv ctx in
-              let ctx, _, _ = Unchecked.db_levels ctx in
-              let ctx = Opposite.ctx ctx [ n ] in
-              let rename x = Display_maps.var_apply_sub x names in
-              let src = Unchecked.sub_apply_sub id names in
-              let tgt_predb =
-                List.map
-                  (fun (x, (y, e)) ->
-                    match y with
-                    | Var a when a = lb || a = ub || a = f ->
-                        (x, (Var (Var.Plus a), e))
-                    | _ -> (x, (y, e)))
-                  id
-              in
-              let tgt = Unchecked.sub_apply_sub tgt_predb names in
-              let lb = Var.Bridge lb in
-              let ub = Var.Bridge ub in
-              let f = Var.Bridge f in
-              (ctx, rename lb, rename ub, rename f, src, tgt)
-        in
-        Hashtbl.add tbl n res;
-        res
-
-  let base_lower n =
-    let _, b, _, _, _, _ = ctx n in
-    b
-
-  let filler n =
-    let _, _, _, f, _, _ = ctx n in
-    f
-
-  let base_upper n =
-    let _, _, b, _, _, _ = ctx n in
-    b
-
-  let bdry_left_gen n =
-    let _, _, _, _, bdry, _ = ctx n in
-    bdry
-
-  let bdry_right_gen n =
-    let _, _, _, _, _, bdry = ctx n in
-    bdry
-
-  let ctx n =
-    let ctx, _, _, _, _, _ = ctx n in
-    ctx
-
-  let rec bdry_left n k =
-    if n <= k then Unchecked.identity (ctx n)
-    else if n = k + 1 then bdry_left_gen n
-    else Unchecked.sub_apply_sub (bdry_left (n - 1) k) (bdry_left_gen n)
-
-  let rec bdry_right n k =
-    if n <= k then Unchecked.identity (ctx n)
-    else if n = k + 1 then bdry_right_gen n
-    else Unchecked.sub_apply_sub (bdry_right (n - 1) k) (bdry_right_gen n)
-end
 
-(* Cylinder inductive relation : a (n+1)-cylinder is a suspended n-cylinder up
-   to an interchanger *)
-module Induct : sig
-  val ctx : int -> ctx
-  val sub : int -> sub
-end = struct
-  (* The suspension opposite of a cone context *)
-  let ctx n =
-    let ctx = Suspension.ctx (Some 1) (Cylinder.ctx (n - 1)) in
-    let ctx, _, _ = Unchecked.db_levels ctx in
-    ctx
-
-  (* substitution from the cylinder context to the suspension a cylinder.
-     This function returns a horribly list, even though the target
-     context is not a pasting scheme *)
-  let fake_sub_ps_unsafe n =
-    let ctx = Cylinder.ctx n in
-    let with_type v = (Var v, fst (List.assoc v ctx)) in
-    let lb k =
-      Display_maps.var_apply_sub (Cylinder.base_lower k)
-        (Cylinder.bdry_left n k)
-    in
-    let lbP k =
-      Display_maps.var_apply_sub (Cylinder.base_lower k)
-        (Cylinder.bdry_right n k)
-    in
-    let ub k =
-      Display_maps.var_apply_sub (Cylinder.base_upper k)
-        (Cylinder.bdry_left n k)
-    in
-    let ubP k =
-      Display_maps.var_apply_sub (Cylinder.base_upper k)
-        (Cylinder.bdry_right n k)
-    in
-    let f k =
-      Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_left n k)
-    in
-    let fP k =
-      Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_right n k)
-    in
-    let fP1 = with_type (fP 1) in
-    let f1 = with_type (f 1) in
-    let lb k = with_type (lb k) in
-    let lbP k = with_type (lbP k) in
-    let ub k = with_type (ub k) in
-    let ubP k = with_type (ubP k) in
-    List.concat
-      [
-        [ (Var (Cylinder.filler n), true) ];
-        List.init
-          (2 * (n - 2))
-          (fun i ->
-            let i = i + 2 in
-            let v =
-              if i mod 2 = 0 then fP (n - (i / 2)) else f (n - ((i - 1) / 2))
-            in
-            (Var v, false));
-        [ (fst @@ wcomp f1 0 (ub n), false) ];
-        List.init
-          (2 * (n - 2))
-          (fun i ->
-            let i = i + 2 in
-            let v =
-              if i mod 2 = 0 then ubP (n - (i / 2)) else ub (n - ((i - 1) / 2))
-            in
-            (fst @@ wcomp f1 0 v, false));
-        [ (fst @@ wcomp (lb n) 0 fP1, false) ];
-        List.init
-          (2 * (n - 2))
-          (fun i ->
-            let i = i + 2 in
-            let v =
-              if i mod 2 = 0 then lbP (n - (i / 2)) else lb (n - ((i - 1) / 2))
-            in
-            (fst @@ wcomp v 0 fP1, false));
-        [ (fst @@ ubP 1, false); (fst @@ lb 1, false) ];
-      ]
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Construct = Construct.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
+  module Opposite = Opposite.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+
+  let wcomp = Construct.wcomp
+
+  (* Cylinder contexts *)
+  module Cylinder = struct
+    let tbl = Hashtbl.create 97
+
+    let rec ctx n =
+      match Hashtbl.find_opt tbl n with
+      | Some res -> res
+      | None ->
+          let res =
+            match n with
+            | n when n <= 0 ->
+                ( Unchecked.ps_to_ctx (Br []),
+                  Var.Db 0,
+                  Var.Db 0,
+                  Var.Db 0,
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ],
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ] )
+            | 1 ->
+                ( Unchecked.ps_to_ctx (Br [ Br [] ]),
+                  Var.Db 0,
+                  Var.Db 1,
+                  Var.Db 2,
+                  [ (Var.Db 0, (Var (Var.Db 0), true)) ],
+                  [ (Var.Db 0, (Var (Var.Db 1), true)) ] )
+            | n ->
+                let ctx, lb, ub, f, _, _ = ctx (n - 1) in
+                let id = Unchecked.identity ctx in
+                let ctx = Functorialisation.ctx ctx [ lb; ub; f ] in
+                let names = Unchecked.db_level_sub_inv ctx in
+                let ctx, _, _ = Unchecked.db_levels ctx in
+                let ctx = Opposite.ctx ctx [ n ] in
+                let rename x = Display_maps.var_apply_sub x names in
+                let src = Unchecked.sub_apply_sub id names in
+                let tgt_predb =
+                  List.map
+                    (fun (x, (y, e)) ->
+                      match y with
+                      | Var a when a = lb || a = ub || a = f ->
+                          (x, (Var (Var.Plus a), e))
+                      | _ -> (x, (y, e)))
+                    id
+                in
+                let tgt = Unchecked.sub_apply_sub tgt_predb names in
+                let lb = Var.Bridge lb in
+                let ub = Var.Bridge ub in
+                let f = Var.Bridge f in
+                (ctx, rename lb, rename ub, rename f, src, tgt)
+          in
+          Hashtbl.add tbl n res;
+          res
 
-  let sub n = Unchecked.sub_ps_to_sub (fake_sub_ps_unsafe n)
-end
+    let base_lower n =
+      let _, b, _, _, _, _ = ctx n in
+      b
 
-(* Binary Composition of cones *)
-module Codim1 = struct
-  let tbl_comp_codim1 = Hashtbl.create 97
-
-  let ctx n =
-    match n with
-    | n when n <= 1 -> assert false
-    | n -> (
-        match Hashtbl.find_opt tbl_comp_codim1 n with
-        | Some res -> res
-        | None ->
-            let ctx, right_incl =
-              Display_maps.pullback (Cylinder.ctx n)
-                (Cylinder.bdry_right n (n - 1))
-                (Cylinder.ctx n)
-                (Cylinder.bdry_left n (n - 1))
-            in
-            let names = Unchecked.db_level_sub_inv ctx in
-            let ctx, _, _ = Unchecked.db_levels ctx in
-            let right_incl = Unchecked.sub_apply_sub right_incl names in
-            let res = (ctx, right_incl) in
-            Hashtbl.add tbl_comp_codim1 n res;
-            res)
-
-  let right_incl n = snd @@ ctx n
-  let ctx n = fst @@ ctx n
-  let left_lbase n = Cylinder.base_lower n
-  let left_ubase n = Cylinder.base_upper n
-  let right_lbase n = Display_maps.var_apply_sub (left_lbase n) (right_incl n)
-  let right_ubase n = Display_maps.var_apply_sub (left_ubase n) (right_incl n)
-  let left_filler n = Cylinder.filler n
-  let right_filler n = Display_maps.var_apply_sub (left_filler n) (right_incl n)
-
-  let compose_dim2 () =
-    let cubcomp =
-      Functorialisation.coh (Builtin.comp_n 2)
-        [ Var.Db 4; Var.Db 3; Var.Db 2; Var.Db 1; Var.Db 0 ]
-    in
-    let left_filler1 =
-      Unchecked.tm_apply_sub (Var (Cylinder.filler 1)) (Cylinder.bdry_left 2 1)
-    in
-    let mid_filler1 =
-      Unchecked.tm_apply_sub (Var (Cylinder.filler 1)) (Cylinder.bdry_right 2 1)
-    in
-    let right_filler1 = Unchecked.tm_apply_sub mid_filler1 (right_incl 2) in
-    let left_lbase1 =
-      Unchecked.tm_apply_sub (Var (Cylinder.filler 0)) (Cylinder.bdry_left 2 0)
-    in
-    let left_ubase1 =
-      Unchecked.tm_apply_sub
-        (Var (Cylinder.filler 0))
-        (Unchecked.sub_apply_sub (Cylinder.bdry_right 1 0)
-           (Cylinder.bdry_left 2 1))
-    in
-    let mid_lbase1 =
-      Unchecked.tm_apply_sub
-        (Var (Cylinder.filler 0))
-        (Unchecked.sub_apply_sub (Cylinder.bdry_left 1 0)
-           (Cylinder.bdry_right 2 1))
-    in
-    let mid_ubase1 =
-      Unchecked.tm_apply_sub (Var (Cylinder.filler 0)) (Cylinder.bdry_right 2 0)
-    in
-    let right_lbase1 = Unchecked.tm_apply_sub mid_lbase1 (right_incl 2) in
-    let right_ubase1 = Unchecked.tm_apply_sub mid_ubase1 (right_incl 2) in
-    let sub_ps =
-      [
-        (Var (right_filler 2), true);
-        (Var (right_ubase 2), false);
-        (Var (right_lbase 2), false);
-        (right_filler1, false);
-        (right_ubase1, false);
-        (right_lbase1, false);
-        (Var (left_filler 2), true);
-        (Var (left_ubase 2), false);
-        (Var (left_lbase 2), false);
-        (mid_filler1, false);
-        (mid_ubase1, false);
-        (mid_lbase1, false);
-        (left_filler1, false);
-        (left_ubase1, false);
-        (left_lbase1, false);
-      ]
-    in
-    let c = Tm.ctx cubcomp in
-    let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
-    let tm = App (cubcomp, sub) in
-    check_term (Ctx.check (ctx 2)) ~name:("cylcomp(2,1,2)", 0, []) tm
-
-  let intch n =
-    let with_type ctx x = (Var x, fst (List.assoc x ctx)) in
-    let ctx_comp = ctx n in
-    let f k =
-      Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_left n k)
-    in
-    let fP k =
-      Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_right n k)
-    in
-    let fP k = Display_maps.var_apply_sub (fP k) (right_incl n) in
-    let llb = left_lbase n in
-    let rlb = right_lbase n in
-    let lub = left_ubase n in
-    let rub = right_ubase n in
-    let inner_intch_lower =
-      Construct.(
-        intch_comp_nm (with_type ctx_comp llb) (with_type ctx_comp rlb)
-          (with_type ctx_comp (fP 1)))
-    in
-    let inner_intch_upper =
-      Construct.(
-        intch_comp_mn
-          (with_type ctx_comp (f 1))
-          (with_type ctx_comp lub) (with_type ctx_comp rub))
-    in
-    let inner_intch_upper = Construct.(inv inner_intch_upper) in
-    let rec wrap_lower k =
-      if k = 0 then inner_intch_lower
-      else
-        let f = with_type ctx_comp (fP (k + 1)) in
-        wcomp (wrap_lower (k - 1)) k f
-    in
-    let rec wrap_upper k =
-      if k = 0 then inner_intch_upper
-      else
-        let f = with_type ctx_comp (f (k + 1)) in
-        wcomp f k (wrap_upper (k - 1))
-    in
-    (wrap_lower (n - 2), wrap_upper (n - 2))
-
-  let rec compose n =
-    match n with
-    | n when n <= 1 -> assert false
-    | 2 -> compose_dim2 ()
-    | _ ->
-        let right_incl_prev = right_incl (n - 1) in
-        let ctx_comp = ctx n in
-        let right_incl = right_incl n in
-        let name = Printf.sprintf "builtin_cylcomp(%d,%d,%d)" n 1 n in
-        let suspcomp =
-          let comp = Suspension.checked_tm (Some 1) (compose (n - 1)) in
-          let ind_sub = Induct.sub n in
-          let sub =
-            Display_maps.glue ind_sub
-              (Unchecked.sub_apply_sub ind_sub right_incl)
-              (Suspension.sub (Some 1) right_incl_prev)
-              (Induct.ctx n)
-              (Suspension.sub (Some 1) (Cylinder.bdry_left (n - 1) (n - 2)))
-          in
-          check_term (Ctx.check ctx_comp) ~name:(name, 0, []) (App (comp, sub))
-        in
-        let intch_lower, intch_upper = intch n in
-        let scomp = (Tm.develop suspcomp, Tm.ty suspcomp) in
-        let tm, _ =
-          Construct.wcomp3 intch_lower (n - 1) scomp (n - 1) intch_upper
-        in
-        check_term (Ctx.check ctx_comp) ~name:(name, 0, []) tm
-end
+    let filler n =
+      let _, _, _, f, _, _ = ctx n in
+      f
 
-module Composition = struct
-  let rec ctx n m k =
-    if n > m then
-      let ctx, llb, lub, lf, rlb, rub, rf = ctx (n - 1) m k in
-      let ctx = Functorialisation.ctx ctx [ llb; lub; lf ] in
-      let names = Unchecked.db_level_sub_inv ctx in
-      let ctx, _, _ = Unchecked.db_levels ctx in
-      let ctx = Opposite.ctx ctx [ n ] in
-      let rename x = Display_maps.var_apply_sub x names in
-      let llb = Var.Bridge llb in
-      let lub = Var.Bridge lub in
-      let lf = Var.Bridge lf in
-      (ctx, rename llb, rename lub, rename lf, rename rlb, rename rub, rename rf)
-    else if m > n then
-      let ctx, llb, lub, lf, rlb, rub, rf = ctx n (m - 1) k in
-      let ctx = Functorialisation.ctx ctx [ rlb; rub; rf ] in
-      let names = Unchecked.db_level_sub_inv ctx in
+    let base_upper n =
+      let _, _, b, _, _, _ = ctx n in
+      b
+
+    let bdry_left_gen n =
+      let _, _, _, _, bdry, _ = ctx n in
+      bdry
+
+    let bdry_right_gen n =
+      let _, _, _, _, _, bdry = ctx n in
+      bdry
+
+    let ctx n =
+      let ctx, _, _, _, _, _ = ctx n in
+      ctx
+
+    let rec bdry_left n k =
+      if n <= k then Unchecked.identity (ctx n)
+      else if n = k + 1 then bdry_left_gen n
+      else Unchecked.sub_apply_sub (bdry_left (n - 1) k) (bdry_left_gen n)
+
+    let rec bdry_right n k =
+      if n <= k then Unchecked.identity (ctx n)
+      else if n = k + 1 then bdry_right_gen n
+      else Unchecked.sub_apply_sub (bdry_right (n - 1) k) (bdry_right_gen n)
+  end
+
+  (* Cylinder inductive relation : a (n+1)-cylinder is a suspended n-cylinder up
+   to an interchanger *)
+  module Induct : sig
+    val ctx : int -> ctx
+    val sub : int -> sub
+  end = struct
+    (* The suspension opposite of a cone context *)
+    let ctx n =
+      let ctx = Suspension.ctx (Some 1) (Cylinder.ctx (n - 1)) in
       let ctx, _, _ = Unchecked.db_levels ctx in
-      let ctx = Opposite.ctx ctx [ m ] in
-      let rename x = Display_maps.var_apply_sub x names in
-      let rlb = Var.Bridge rlb in
-      let rub = Var.Bridge rub in
-      let rf = Var.Bridge rf in
-      (ctx, rename llb, rename lub, rename lf, rename rlb, rename rub, rename rf)
-    else
-      match n - k with
-      | i when i <= 0 -> assert false
-      | 1 ->
-          let llb = Cylinder.base_lower n in
-          let lub = Cylinder.base_upper n in
-          let lf = Cylinder.filler n in
-          let rlb =
-            Display_maps.var_apply_sub (Cylinder.base_lower n)
-              (Codim1.right_incl n)
-          in
-          let rub =
-            Display_maps.var_apply_sub (Cylinder.base_upper n)
-              (Codim1.right_incl n)
-          in
-          let rf =
-            Display_maps.var_apply_sub (Cylinder.filler n) (Codim1.right_incl n)
-          in
-          (Codim1.ctx n, llb, lub, lf, rlb, rub, rf)
-      | _ ->
-          let ctx, llb, lub, lf, rlb, rub, rf = ctx (n - 1) (m - 1) k in
-          let ctx = Functorialisation.ctx ctx [ llb; lub; lf; rlb; rub; rf ] in
-          let names = Unchecked.db_level_sub_inv ctx in
-          let ctx, _, _ = Unchecked.db_levels ctx in
-          let rename x = Display_maps.var_apply_sub x names in
-          let llb = Var.Bridge llb in
-          let lub = Var.Bridge lub in
-          let lf = Var.Bridge lf in
-          let rlb = Var.Bridge rlb in
-          let rub = Var.Bridge rub in
-          let rf = Var.Bridge rf in
-          ( ctx,
-            rename llb,
-            rename lub,
-            rename lf,
-            rename rlb,
-            rename rub,
-            rename rf )
-
-  let left_base_lower n m k =
-    let _, llb, _, _, _, _, _ = ctx n m k in
-    llb
-
-  let left_base_upper n m k =
-    let _, _, lub, _, _, _, _ = ctx n m k in
-    lub
-
-  let right_base_lower n m k =
-    let _, _, _, _, rlb, _, _ = ctx n m k in
-    rlb
-
-  let right_base_upper n m k =
-    let _, _, _, _, _, rub, _ = ctx n m k in
-    rub
-
-  let left_filler n m k =
-    let _, _, _, lf, _, _, _ = ctx n m k in
-    lf
-
-  let right_filler n m k =
-    let _, _, _, _, _, _, rf = ctx n m k in
-    rf
-
-  let tbl = Hashtbl.create 97
-
-  let rec compose n m k =
-    match Hashtbl.find_opt tbl (n, m, k) with
-    | Some res -> res
-    | None ->
-        let tm =
-          if n > m then
-            Opposite.checked_tm
-              (Functorialisation.tm
-                 (compose (n - 1) m k)
-                 [
-                   (left_base_lower (n - 1) m k, 1);
-                   (left_base_upper (n - 1) m k, 1);
-                   (left_filler (n - 1) m k, 1);
-                 ])
-              [ n ]
-          else if m > n then
-            Opposite.checked_tm
-              (Functorialisation.tm
-                 (compose n (m - 1) k)
-                 [
-                   (right_base_lower n (m - 1) k, 1);
-                   (right_base_upper n (m - 1) k, 1);
-                   (right_filler n (m - 1) k, 1);
-                 ])
-              [ m ]
-          else
-            match n - k with
-            | i when i <= 0 -> assert false
-            | 1 -> Codim1.compose n
-            | _ ->
-                Opposite.checked_tm
-                  (Functorialisation.tm
-                     (compose (n - 1) (m - 1) k)
-                     [
-                       (left_base_lower (n - 1) (m - 1) k, 1);
-                       (left_base_upper (n - 1) (m - 1) k, 1);
-                       (left_filler (n - 1) (m - 1) k, 1);
-                       (right_base_lower (n - 1) (m - 1) k, 1);
-                       (right_base_upper (n - 1) (m - 1) k, 1);
-                       (right_filler (n - 1) (m - 1) k, 1);
-                     ])
-                  [ n ]
-        in
-        let ctx = Tm.ctx tm in
-        let names = Unchecked.db_level_sub_inv ctx in
-        let ctx, _, _ = Unchecked.db_levels ctx in
-        let tm = Unchecked.tm_apply_sub (Tm.develop tm) names in
-        let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" n k m in
-        let res = check_term (Ctx.check ctx) ~name:(name, 0, []) tm in
-        Hashtbl.add tbl (n, m, k) res;
-        res
-end
+      ctx
 
-let compose = Composition.compose
+    (* substitution from the cylinder context to the suspension a cylinder.
+     This function returns a horribly list, even though the target
+     context is not a pasting scheme *)
+    let fake_sub_ps_unsafe n =
+      let ctx = Cylinder.ctx n in
+      let with_type v = (Var v, fst (List.assoc v ctx)) in
+      let lb k =
+        Display_maps.var_apply_sub (Cylinder.base_lower k)
+          (Cylinder.bdry_left n k)
+      in
+      let lbP k =
+        Display_maps.var_apply_sub (Cylinder.base_lower k)
+          (Cylinder.bdry_right n k)
+      in
+      let ub k =
+        Display_maps.var_apply_sub (Cylinder.base_upper k)
+          (Cylinder.bdry_left n k)
+      in
+      let ubP k =
+        Display_maps.var_apply_sub (Cylinder.base_upper k)
+          (Cylinder.bdry_right n k)
+      in
+      let f k =
+        Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_left n k)
+      in
+      let fP k =
+        Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_right n k)
+      in
+      let fP1 = with_type (fP 1) in
+      let f1 = with_type (f 1) in
+      let lb k = with_type (lb k) in
+      let lbP k = with_type (lbP k) in
+      let ub k = with_type (ub k) in
+      let ubP k = with_type (ubP k) in
+      List.concat
+        [
+          [ (Var (Cylinder.filler n), true) ];
+          List.init
+            (2 * (n - 2))
+            (fun i ->
+              let i = i + 2 in
+              let v =
+                if i mod 2 = 0 then fP (n - (i / 2)) else f (n - ((i - 1) / 2))
+              in
+              (Var v, false));
+          [ (fst @@ wcomp f1 0 (ub n), false) ];
+          List.init
+            (2 * (n - 2))
+            (fun i ->
+              let i = i + 2 in
+              let v =
+                if i mod 2 = 0 then ubP (n - (i / 2)) else ub (n - ((i - 1) / 2))
+              in
+              (fst @@ wcomp f1 0 v, false));
+          [ (fst @@ wcomp (lb n) 0 fP1, false) ];
+          List.init
+            (2 * (n - 2))
+            (fun i ->
+              let i = i + 2 in
+              let v =
+                if i mod 2 = 0 then lbP (n - (i / 2)) else lb (n - ((i - 1) / 2))
+              in
+              (fst @@ wcomp v 0 fP1, false));
+          [ (fst @@ ubP 1, false); (fst @@ lb 1, false) ];
+        ]
 
-module Stacking = struct
-  let tbl_stacking_ctx = Hashtbl.create 97
-  let tbl_stacking_tm = Hashtbl.create 97
+    let sub n = Unchecked.sub_ps_to_sub (fake_sub_ps_unsafe n)
+  end
 
-  let rec ctx n =
-    let res =
+  (* Binary Composition of cones *)
+  module Codim1 = struct
+    let tbl_comp_codim1 = Hashtbl.create 97
+
+    let ctx n =
       match n with
       | n when n <= 1 -> assert false
-      | n when n = 2 ->
-          let ctx = Cylinder.ctx 2 in
-          let base_lower = Cylinder.base_lower 2 in
-          let base_upper = Cylinder.base_upper 2 in
-          let char v =
-            Unchecked.sub_ps_to_sub
-              ((Var v, true) :: Unchecked.ty_to_sub_ps (fst (List.assoc v ctx)))
-          in
-          let ctx, upper_incl =
-            Display_maps.pullback (Cylinder.ctx 2) (char base_upper)
-              (Cylinder.ctx 2) (char base_lower)
-          in
-          let names = Unchecked.db_level_sub_inv ctx in
-          let ctx, _, _ = Unchecked.db_levels ctx in
-          let upper_incl = Unchecked.sub_apply_sub upper_incl names in
-          (ctx, upper_incl)
-      | n ->
-          let ctx, upper_incl = ctx (n - 1) in
-          let lb = Cylinder.base_lower (n - 1) in
-          let mb = Cylinder.base_upper (n - 1) in
-          let ub = Display_maps.var_apply_sub mb upper_incl in
-          let lf = Cylinder.filler (n - 1) in
-          let uf = Display_maps.var_apply_sub lf upper_incl in
-          let var_fun = [ lb; mb; lf; ub; uf ] in
-          let ctx = Functorialisation.ctx ctx var_fun in
-          let ctx = Opposite.ctx ctx [ n ] in
-          let upper_incl = Functorialisation.sub upper_incl var_fun in
-          let upper_incl = Opposite.sub upper_incl [ n ] in
-          let names = Unchecked.db_level_sub_inv ctx in
-          let ctx, _, _ = Unchecked.db_levels ctx in
-          let upper_incl = Unchecked.sub_apply_sub upper_incl names in
-          let upper_incl =
-            Unchecked.(sub_ps_to_sub (sub_to_sub_ps upper_incl))
-          in
-          (ctx, upper_incl)
-    in
-    Hashtbl.add tbl_stacking_ctx n res;
-    res
-
-  let rec stacking n =
-    let res =
+      | n -> (
+          match Hashtbl.find_opt tbl_comp_codim1 n with
+          | Some res -> res
+          | None ->
+              let ctx, right_incl =
+                Display_maps.pullback (Cylinder.ctx n)
+                  (Cylinder.bdry_right n (n - 1))
+                  (Cylinder.ctx n)
+                  (Cylinder.bdry_left n (n - 1))
+              in
+              let names = Unchecked.db_level_sub_inv ctx in
+              let ctx, _, _ = Unchecked.db_levels ctx in
+              let right_incl = Unchecked.sub_apply_sub right_incl names in
+              let res = (ctx, right_incl) in
+              Hashtbl.add tbl_comp_codim1 n res;
+              res)
+
+    let right_incl n = snd @@ ctx n
+    let ctx n = fst @@ ctx n
+    let left_lbase n = Cylinder.base_lower n
+    let left_ubase n = Cylinder.base_upper n
+    let right_lbase n = Display_maps.var_apply_sub (left_lbase n) (right_incl n)
+    let right_ubase n = Display_maps.var_apply_sub (left_ubase n) (right_incl n)
+    let left_filler n = Cylinder.filler n
+
+    let right_filler n =
+      Display_maps.var_apply_sub (left_filler n) (right_incl n)
+
+    let compose_dim2 () =
+      let cubcomp =
+        Functorialisation.coh (Builtin.comp_n 2)
+          [ Var.Db 4; Var.Db 3; Var.Db 2; Var.Db 1; Var.Db 0 ]
+      in
+      let left_filler1 =
+        Unchecked.tm_apply_sub
+          (Var (Cylinder.filler 1))
+          (Cylinder.bdry_left 2 1)
+      in
+      let mid_filler1 =
+        Unchecked.tm_apply_sub
+          (Var (Cylinder.filler 1))
+          (Cylinder.bdry_right 2 1)
+      in
+      let right_filler1 = Unchecked.tm_apply_sub mid_filler1 (right_incl 2) in
+      let left_lbase1 =
+        Unchecked.tm_apply_sub
+          (Var (Cylinder.filler 0))
+          (Cylinder.bdry_left 2 0)
+      in
+      let left_ubase1 =
+        Unchecked.tm_apply_sub
+          (Var (Cylinder.filler 0))
+          (Unchecked.sub_apply_sub (Cylinder.bdry_right 1 0)
+             (Cylinder.bdry_left 2 1))
+      in
+      let mid_lbase1 =
+        Unchecked.tm_apply_sub
+          (Var (Cylinder.filler 0))
+          (Unchecked.sub_apply_sub (Cylinder.bdry_left 1 0)
+             (Cylinder.bdry_right 2 1))
+      in
+      let mid_ubase1 =
+        Unchecked.tm_apply_sub
+          (Var (Cylinder.filler 0))
+          (Cylinder.bdry_right 2 0)
+      in
+      let right_lbase1 = Unchecked.tm_apply_sub mid_lbase1 (right_incl 2) in
+      let right_ubase1 = Unchecked.tm_apply_sub mid_ubase1 (right_incl 2) in
+      let sub_ps =
+        [
+          (Var (right_filler 2), true);
+          (Var (right_ubase 2), false);
+          (Var (right_lbase 2), false);
+          (right_filler1, false);
+          (right_ubase1, false);
+          (right_lbase1, false);
+          (Var (left_filler 2), true);
+          (Var (left_ubase 2), false);
+          (Var (left_lbase 2), false);
+          (mid_filler1, false);
+          (mid_ubase1, false);
+          (mid_lbase1, false);
+          (left_filler1, false);
+          (left_ubase1, false);
+          (left_lbase1, false);
+        ]
+      in
+      let c = Tm.ctx cubcomp in
+      let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
+      let tm = App (cubcomp, sub) in
+      check_term (Ctx.check (ctx 2)) ~name:("cylcomp(2,1,2)", 0, []) tm
+
+    let intch n =
+      let with_type ctx x = (Var x, fst (List.assoc x ctx)) in
+      let ctx_comp = ctx n in
+      let f k =
+        Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_left n k)
+      in
+      let fP k =
+        Display_maps.var_apply_sub (Cylinder.filler k) (Cylinder.bdry_right n k)
+      in
+      let fP k = Display_maps.var_apply_sub (fP k) (right_incl n) in
+      let llb = left_lbase n in
+      let rlb = right_lbase n in
+      let lub = left_ubase n in
+      let rub = right_ubase n in
+      let inner_intch_lower =
+        Construct.(
+          intch_comp_nm (with_type ctx_comp llb) (with_type ctx_comp rlb)
+            (with_type ctx_comp (fP 1)))
+      in
+      let inner_intch_upper =
+        Construct.(
+          intch_comp_mn
+            (with_type ctx_comp (f 1))
+            (with_type ctx_comp lub) (with_type ctx_comp rub))
+      in
+      let inner_intch_upper = Construct.(inv inner_intch_upper) in
+      let rec wrap_lower k =
+        if k = 0 then inner_intch_lower
+        else
+          let f = with_type ctx_comp (fP (k + 1)) in
+          wcomp (wrap_lower (k - 1)) k f
+      in
+      let rec wrap_upper k =
+        if k = 0 then inner_intch_upper
+        else
+          let f = with_type ctx_comp (f (k + 1)) in
+          wcomp f k (wrap_upper (k - 1))
+      in
+      (wrap_lower (n - 2), wrap_upper (n - 2))
+
+    let rec compose n =
       match n with
       | n when n <= 1 -> assert false
-      | n when n = 2 ->
-          let ctx, upper_incl = ctx 2 in
-          let tm =
-            Functorialisation.coh (Builtin.comp_n 2)
-              [ Var.Db 4; Var.Db 3; Var.Db 2; Var.Db 1; Var.Db 0 ]
-          in
-          let tm = Opposite.checked_tm tm [ 2 ] in
-          let left_filler1_down =
-            Unchecked.tm_apply_sub
-              (Var (Cylinder.filler 1))
-              (Cylinder.bdry_left 2 1)
-          in
-          let right_filler1_down =
-            Unchecked.tm_apply_sub
-              (Var (Cylinder.filler 1))
-              (Cylinder.bdry_right 2 1)
-          in
-          let left_filler1_up =
-            Unchecked.tm_apply_sub left_filler1_down upper_incl
-          in
-          let right_filler1_up =
-            Unchecked.tm_apply_sub right_filler1_down upper_incl
-          in
-          let lower_base1_down =
-            Unchecked.tm_apply_sub
-              (Var (Cylinder.filler 0))
-              (Cylinder.bdry_left 2 0)
-          in
-          let lower_base1_mid =
-            Unchecked.tm_apply_sub
-              (Var (Cylinder.filler 0))
-              (Unchecked.sub_apply_sub (Cylinder.bdry_right 1 0)
-                 (Cylinder.bdry_left 2 1))
-          in
-          let upper_base1_down =
-            Unchecked.tm_apply_sub
-              (Var (Cylinder.filler 0))
-              (Unchecked.sub_apply_sub (Cylinder.bdry_left 1 0)
-                 (Cylinder.bdry_right 2 1))
-          in
-          let upper_base1_mid =
-            Unchecked.tm_apply_sub
-              (Var (Cylinder.filler 0))
-              (Cylinder.bdry_right 2 0)
-          in
-          let lower_base1_up =
-            Unchecked.tm_apply_sub lower_base1_mid upper_incl
+      | 2 -> compose_dim2 ()
+      | _ ->
+          let right_incl_prev = right_incl (n - 1) in
+          let ctx_comp = ctx n in
+          let right_incl = right_incl n in
+          let name = Printf.sprintf "builtin_cylcomp(%d,%d,%d)" n 1 n in
+          let suspcomp =
+            let comp = Suspension.checked_tm (Some 1) (compose (n - 1)) in
+            let ind_sub = Induct.sub n in
+            let sub =
+              Display_maps.glue ind_sub
+                (Unchecked.sub_apply_sub ind_sub right_incl)
+                (Suspension.sub (Some 1) right_incl_prev)
+                (Induct.ctx n)
+                (Suspension.sub (Some 1) (Cylinder.bdry_left (n - 1) (n - 2)))
+            in
+            check_term (Ctx.check ctx_comp) ~name:(name, 0, [])
+              (App (comp, sub))
           in
-          let upper_base1_up =
-            Unchecked.tm_apply_sub upper_base1_mid upper_incl
+          let intch_lower, intch_upper = intch n in
+          let scomp = (Tm.develop suspcomp, Tm.ty suspcomp) in
+          let tm, _ =
+            Construct.wcomp3 intch_lower (n - 1) scomp (n - 1) intch_upper
           in
-          let base2_down = Var (Cylinder.base_lower 2) in
-          let base2_mid = Var (Cylinder.base_upper 2) in
-          let base2_up = Unchecked.tm_apply_sub base2_mid upper_incl in
-          let filler2_down = Var (Cylinder.filler 2) in
-          let filler2_up = Unchecked.tm_apply_sub filler2_down upper_incl in
-          let sub_ps =
-            [
-              (filler2_up, true);
-              (right_filler1_up, false);
-              (left_filler1_up, false);
-              (base2_up, false);
-              (upper_base1_up, false);
-              (lower_base1_up, false);
-              (filler2_down, true);
-              (right_filler1_down, false);
-              (left_filler1_down, false);
-              (base2_mid, false);
-              (upper_base1_mid, false);
-              (lower_base1_mid, false);
-              (base2_down, false);
-              (upper_base1_down, false);
-              (lower_base1_down, false);
-            ]
+          check_term (Ctx.check ctx_comp) ~name:(name, 0, []) tm
+  end
+
+  module Composition = struct
+    let rec ctx n m k =
+      if n > m then
+        let ctx, llb, lub, lf, rlb, rub, rf = ctx (n - 1) m k in
+        let ctx = Functorialisation.ctx ctx [ llb; lub; lf ] in
+        let names = Unchecked.db_level_sub_inv ctx in
+        let ctx, _, _ = Unchecked.db_levels ctx in
+        let ctx = Opposite.ctx ctx [ n ] in
+        let rename x = Display_maps.var_apply_sub x names in
+        let llb = Var.Bridge llb in
+        let lub = Var.Bridge lub in
+        let lf = Var.Bridge lf in
+        ( ctx,
+          rename llb,
+          rename lub,
+          rename lf,
+          rename rlb,
+          rename rub,
+          rename rf )
+      else if m > n then
+        let ctx, llb, lub, lf, rlb, rub, rf = ctx n (m - 1) k in
+        let ctx = Functorialisation.ctx ctx [ rlb; rub; rf ] in
+        let names = Unchecked.db_level_sub_inv ctx in
+        let ctx, _, _ = Unchecked.db_levels ctx in
+        let ctx = Opposite.ctx ctx [ m ] in
+        let rename x = Display_maps.var_apply_sub x names in
+        let rlb = Var.Bridge rlb in
+        let rub = Var.Bridge rub in
+        let rf = Var.Bridge rf in
+        ( ctx,
+          rename llb,
+          rename lub,
+          rename lf,
+          rename rlb,
+          rename rub,
+          rename rf )
+      else
+        match n - k with
+        | i when i <= 0 -> assert false
+        | 1 ->
+            let llb = Cylinder.base_lower n in
+            let lub = Cylinder.base_upper n in
+            let lf = Cylinder.filler n in
+            let rlb =
+              Display_maps.var_apply_sub (Cylinder.base_lower n)
+                (Codim1.right_incl n)
+            in
+            let rub =
+              Display_maps.var_apply_sub (Cylinder.base_upper n)
+                (Codim1.right_incl n)
+            in
+            let rf =
+              Display_maps.var_apply_sub (Cylinder.filler n)
+                (Codim1.right_incl n)
+            in
+            (Codim1.ctx n, llb, lub, lf, rlb, rub, rf)
+        | _ ->
+            let ctx, llb, lub, lf, rlb, rub, rf = ctx (n - 1) (m - 1) k in
+            let ctx =
+              Functorialisation.ctx ctx [ llb; lub; lf; rlb; rub; rf ]
+            in
+            let names = Unchecked.db_level_sub_inv ctx in
+            let ctx, _, _ = Unchecked.db_levels ctx in
+            let rename x = Display_maps.var_apply_sub x names in
+            let llb = Var.Bridge llb in
+            let lub = Var.Bridge lub in
+            let lf = Var.Bridge lf in
+            let rlb = Var.Bridge rlb in
+            let rub = Var.Bridge rub in
+            let rf = Var.Bridge rf in
+            ( ctx,
+              rename llb,
+              rename lub,
+              rename lf,
+              rename rlb,
+              rename rub,
+              rename rf )
+
+    let left_base_lower n m k =
+      let _, llb, _, _, _, _, _ = ctx n m k in
+      llb
+
+    let left_base_upper n m k =
+      let _, _, lub, _, _, _, _ = ctx n m k in
+      lub
+
+    let right_base_lower n m k =
+      let _, _, _, _, rlb, _, _ = ctx n m k in
+      rlb
+
+    let right_base_upper n m k =
+      let _, _, _, _, _, rub, _ = ctx n m k in
+      rub
+
+    let left_filler n m k =
+      let _, _, _, lf, _, _, _ = ctx n m k in
+      lf
+
+    let right_filler n m k =
+      let _, _, _, _, _, _, rf = ctx n m k in
+      rf
+
+    let tbl = Hashtbl.create 97
+
+    let rec compose n m k =
+      match Hashtbl.find_opt tbl (n, m, k) with
+      | Some res -> res
+      | None ->
+          let tm =
+            if n > m then
+              Opposite.checked_tm
+                (Functorialisation.tm
+                   (compose (n - 1) m k)
+                   [
+                     (left_base_lower (n - 1) m k, 1);
+                     (left_base_upper (n - 1) m k, 1);
+                     (left_filler (n - 1) m k, 1);
+                   ])
+                [ n ]
+            else if m > n then
+              Opposite.checked_tm
+                (Functorialisation.tm
+                   (compose n (m - 1) k)
+                   [
+                     (right_base_lower n (m - 1) k, 1);
+                     (right_base_upper n (m - 1) k, 1);
+                     (right_filler n (m - 1) k, 1);
+                   ])
+                [ m ]
+            else
+              match n - k with
+              | i when i <= 0 -> assert false
+              | 1 -> Codim1.compose n
+              | _ ->
+                  Opposite.checked_tm
+                    (Functorialisation.tm
+                       (compose (n - 1) (m - 1) k)
+                       [
+                         (left_base_lower (n - 1) (m - 1) k, 1);
+                         (left_base_upper (n - 1) (m - 1) k, 1);
+                         (left_filler (n - 1) (m - 1) k, 1);
+                         (right_base_lower (n - 1) (m - 1) k, 1);
+                         (right_base_upper (n - 1) (m - 1) k, 1);
+                         (right_filler (n - 1) (m - 1) k, 1);
+                       ])
+                    [ n ]
           in
-          let c = Tm.ctx tm in
-          let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
-          check_term (Ctx.check ctx)
-            ~name:("builtin_cylstack", 0, [])
-            (App (tm, sub))
-      | n ->
-          let _, upper_incl = ctx (n - 1) in
-          let lb = Cylinder.base_lower (n - 1) in
-          let mb = Cylinder.base_upper (n - 1) in
-          let ub = Display_maps.var_apply_sub mb upper_incl in
-          let lf = Cylinder.filler (n - 1) in
-          let uf = Display_maps.var_apply_sub lf upper_incl in
-          let tm = stacking (n - 1) in
-          let var_fun = [ (lb, 1); (mb, 1); (lf, 1); (ub, 1); (uf, 1) ] in
-          let tm = Functorialisation.tm tm var_fun in
-          let tm = Opposite.checked_tm tm [ n ] in
-          tm
-    in
-    Hashtbl.add tbl_stacking_tm n res;
-    res
+          let ctx = Tm.ctx tm in
+          let names = Unchecked.db_level_sub_inv ctx in
+          let ctx, _, _ = Unchecked.db_levels ctx in
+          let tm = Unchecked.tm_apply_sub (Tm.develop tm) names in
+          let name = Printf.sprintf "builtin_conecomp(%d,%d,%d)" n k m in
+          let res = check_term (Ctx.check ctx) ~name:(name, 0, []) tm in
+          Hashtbl.add tbl (n, m, k) res;
+          res
+  end
+
+  let compose = Composition.compose
+
+  module Stacking = struct
+    let tbl_stacking_ctx = Hashtbl.create 97
+    let tbl_stacking_tm = Hashtbl.create 97
+
+    let rec ctx n =
+      let res =
+        match n with
+        | n when n <= 1 -> assert false
+        | n when n = 2 ->
+            let ctx = Cylinder.ctx 2 in
+            let base_lower = Cylinder.base_lower 2 in
+            let base_upper = Cylinder.base_upper 2 in
+            let char v =
+              Unchecked.sub_ps_to_sub
+                ((Var v, true)
+                :: Unchecked.ty_to_sub_ps (fst (List.assoc v ctx)))
+            in
+            let ctx, upper_incl =
+              Display_maps.pullback (Cylinder.ctx 2) (char base_upper)
+                (Cylinder.ctx 2) (char base_lower)
+            in
+            let names = Unchecked.db_level_sub_inv ctx in
+            let ctx, _, _ = Unchecked.db_levels ctx in
+            let upper_incl = Unchecked.sub_apply_sub upper_incl names in
+            (ctx, upper_incl)
+        | n ->
+            let ctx, upper_incl = ctx (n - 1) in
+            let lb = Cylinder.base_lower (n - 1) in
+            let mb = Cylinder.base_upper (n - 1) in
+            let ub = Display_maps.var_apply_sub mb upper_incl in
+            let lf = Cylinder.filler (n - 1) in
+            let uf = Display_maps.var_apply_sub lf upper_incl in
+            let var_fun = [ lb; mb; lf; ub; uf ] in
+            let ctx = Functorialisation.ctx ctx var_fun in
+            let ctx = Opposite.ctx ctx [ n ] in
+            let upper_incl = Functorialisation.sub upper_incl var_fun in
+            let upper_incl = Opposite.sub upper_incl [ n ] in
+            let names = Unchecked.db_level_sub_inv ctx in
+            let ctx, _, _ = Unchecked.db_levels ctx in
+            let upper_incl = Unchecked.sub_apply_sub upper_incl names in
+            let upper_incl =
+              Unchecked.(sub_ps_to_sub (sub_to_sub_ps upper_incl))
+            in
+            (ctx, upper_incl)
+      in
+      Hashtbl.add tbl_stacking_ctx n res;
+      res
+
+    let rec stacking n =
+      let res =
+        match n with
+        | n when n <= 1 -> assert false
+        | n when n = 2 ->
+            let ctx, upper_incl = ctx 2 in
+            let tm =
+              Functorialisation.coh (Builtin.comp_n 2)
+                [ Var.Db 4; Var.Db 3; Var.Db 2; Var.Db 1; Var.Db 0 ]
+            in
+            let tm = Opposite.checked_tm tm [ 2 ] in
+            let left_filler1_down =
+              Unchecked.tm_apply_sub
+                (Var (Cylinder.filler 1))
+                (Cylinder.bdry_left 2 1)
+            in
+            let right_filler1_down =
+              Unchecked.tm_apply_sub
+                (Var (Cylinder.filler 1))
+                (Cylinder.bdry_right 2 1)
+            in
+            let left_filler1_up =
+              Unchecked.tm_apply_sub left_filler1_down upper_incl
+            in
+            let right_filler1_up =
+              Unchecked.tm_apply_sub right_filler1_down upper_incl
+            in
+            let lower_base1_down =
+              Unchecked.tm_apply_sub
+                (Var (Cylinder.filler 0))
+                (Cylinder.bdry_left 2 0)
+            in
+            let lower_base1_mid =
+              Unchecked.tm_apply_sub
+                (Var (Cylinder.filler 0))
+                (Unchecked.sub_apply_sub (Cylinder.bdry_right 1 0)
+                   (Cylinder.bdry_left 2 1))
+            in
+            let upper_base1_down =
+              Unchecked.tm_apply_sub
+                (Var (Cylinder.filler 0))
+                (Unchecked.sub_apply_sub (Cylinder.bdry_left 1 0)
+                   (Cylinder.bdry_right 2 1))
+            in
+            let upper_base1_mid =
+              Unchecked.tm_apply_sub
+                (Var (Cylinder.filler 0))
+                (Cylinder.bdry_right 2 0)
+            in
+            let lower_base1_up =
+              Unchecked.tm_apply_sub lower_base1_mid upper_incl
+            in
+            let upper_base1_up =
+              Unchecked.tm_apply_sub upper_base1_mid upper_incl
+            in
+            let base2_down = Var (Cylinder.base_lower 2) in
+            let base2_mid = Var (Cylinder.base_upper 2) in
+            let base2_up = Unchecked.tm_apply_sub base2_mid upper_incl in
+            let filler2_down = Var (Cylinder.filler 2) in
+            let filler2_up = Unchecked.tm_apply_sub filler2_down upper_incl in
+            let sub_ps =
+              [
+                (filler2_up, true);
+                (right_filler1_up, false);
+                (left_filler1_up, false);
+                (base2_up, false);
+                (upper_base1_up, false);
+                (lower_base1_up, false);
+                (filler2_down, true);
+                (right_filler1_down, false);
+                (left_filler1_down, false);
+                (base2_mid, false);
+                (upper_base1_mid, false);
+                (lower_base1_mid, false);
+                (base2_down, false);
+                (upper_base1_down, false);
+                (lower_base1_down, false);
+              ]
+            in
+            let c = Tm.ctx tm in
+            let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
+            check_term (Ctx.check ctx)
+              ~name:("builtin_cylstack", 0, [])
+              (App (tm, sub))
+        | n ->
+            let _, upper_incl = ctx (n - 1) in
+            let lb = Cylinder.base_lower (n - 1) in
+            let mb = Cylinder.base_upper (n - 1) in
+            let ub = Display_maps.var_apply_sub mb upper_incl in
+            let lf = Cylinder.filler (n - 1) in
+            let uf = Display_maps.var_apply_sub lf upper_incl in
+            let tm = stacking (n - 1) in
+            let var_fun = [ (lb, 1); (mb, 1); (lf, 1); (ub, 1); (uf, 1) ] in
+            let tm = Functorialisation.tm tm var_fun in
+            let tm = Opposite.checked_tm tm [ n ] in
+            tm
+      in
+      Hashtbl.add tbl_stacking_tm n res;
+      res
+  end
+
+  let stacking = Stacking.stacking
 end
-
-let stacking = Stacking.stacking
diff --git a/lib/meta_operations/cylinders.mli b/lib/meta_operations/cylinders.mli
index ee8fdf2e..5fa67970 100644
--- a/lib/meta_operations/cylinders.mli
+++ b/lib/meta_operations/cylinders.mli
@@ -1,4 +1,6 @@
-open Kernel
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val compose : int -> int -> int -> Tm.t
-val stacking : int -> Tm.t
+  val compose : int -> int -> int -> Tm.t
+  val stacking : int -> Tm.t
+end
diff --git a/lib/meta_operations/eh.ml b/lib/meta_operations/eh.ml
index d1c476d0..2167ceb9 100644
--- a/lib/meta_operations/eh.ml
+++ b/lib/meta_operations/eh.ml
@@ -1,609 +1,621 @@
 open Common
-open Kernel
 
-module type EHArgsS = sig
-  val n : int
-  val k : int
-  val l : int
-end
-
-module type BiasedPaddingArgsS = sig
-  val n : int
-end
-
-let memo_args = Hashtbl.create 97
-let memo_args_biased = Hashtbl.create 97
-
-let args n k l =
-  match Hashtbl.find_opt memo_args (n, k, l) with
-  | Some m -> m
-  | None ->
-      let res =
-        (module struct
-          let n = n
-          let k = k
-          let l = l
-        end : EHArgsS)
-      in
-      Hashtbl.add memo_args (n, k, l) res;
-      res
-
-let args_biased n =
-  match Hashtbl.find_opt memo_args_biased n with
-  | Some m -> m
-  | None ->
-      let res =
-        (module struct
-          let n = n
-        end : BiasedPaddingArgsS)
-      in
-      Hashtbl.add memo_args_biased n res;
-      res
-
-module UnbiasedPadding (Args : EHArgsS) = Padding.Padding.MakeCanonical (struct
-  let name = "UBPad"
-  let x = Var.Db 0
-  let x_constr = (Var x, Obj)
-
-  let id2 i j =
-    let id = Construct.id_n i (Var x, Obj) in
-    if j < i then Construct.wcomp id j id else id
-
-  let id_l_id i = id2 i Args.l
-
-  module F = Padding.Filtration.Make (struct
-    let min = Int.min Args.k Args.l + 1
-    let max = Args.n
-    let v _ = Var.Db 1
-    let ty i = Construct.arr (id_l_id i) (id_l_id i)
-    let ctx i = [ (v i, (ty (i - 1), true)); (x, (Obj, false)) ]
-  end)
-
-  module D = struct
-    let ps _ = Unchecked.disc 0
-    let p_src i = id2 i Args.k
-    let q_tgt i = id2 i Args.k
-    let p_inc _ = [ x_constr ]
-    let q_inc _ = [ x_constr ]
-
-    let pad_in_ps i =
-      [ (F.v i, (Construct.to_tm (id_l_id i), true)); (x, (Var x, false)) ]
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Construct = Construct.Make (Theory)
+  module Padding = Padding.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+  module Comp = Comp.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Opposite = Opposite.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
+  module Inverse = Inverse.Make (Theory)
+
+  module type EHArgsS = sig
+    val n : int
+    val k : int
+    val l : int
   end
-end)
-
-(* Find a good place for these *)
-let d_src i = (Var (Var.Db (2 * i)), Unchecked.disc_type i)
-let d_tgt i = (Var (Var.Db ((2 * i) + 1)), Unchecked.disc_type i)
-
-let t_comp_id d t =
-  if d = 0 then t else Construct.(wcomp t 0 (id_n d (d_tgt 0)))
 
-module ForwardBiasedPadding (Args : BiasedPaddingArgsS) =
-Padding.Padding.MakeCanonical (struct
-  let name = "FPad"
+  module type BiasedPaddingArgsS = sig
+    val n : int
+  end
 
-  module F = Padding.Filtration.Make (struct
-    let min = 1
-    let max = Args.n
-    let ctx i = Unchecked.ps_to_ctx (Unchecked.disc i)
-    let v i = Var.Db (2 * i)
+  let memo_args = Hashtbl.create 97
+  let memo_args_biased = Hashtbl.create 97
+
+  let args n k l =
+    match Hashtbl.find_opt memo_args (n, k, l) with
+    | Some m -> m
+    | None ->
+        let res =
+          (module struct
+            let n = n
+            let k = k
+            let l = l
+          end : EHArgsS)
+        in
+        Hashtbl.add memo_args (n, k, l) res;
+        res
+
+  let args_biased n =
+    match Hashtbl.find_opt memo_args_biased n with
+    | Some m -> m
+    | None ->
+        let res =
+          (module struct
+            let n = n
+          end : BiasedPaddingArgsS)
+        in
+        Hashtbl.add memo_args_biased n res;
+        res
+
+  module UnbiasedPadding (Args : EHArgsS) =
+  Padding.Padding.MakeCanonical (struct
+    let name = "UBPad"
+    let x = Var.Db 0
+    let x_constr = (Var x, Obj)
+
+    let id2 i j =
+      let id = Construct.id_n i (Var x, Obj) in
+      if j < i then Construct.wcomp id j id else id
+
+    let id_l_id i = id2 i Args.l
+
+    module F = Padding.Filtration.Make (struct
+      let min = Int.min Args.k Args.l + 1
+      let max = Args.n
+      let v _ = Var.Db 1
+      let ty i = Construct.arr (id_l_id i) (id_l_id i)
+      let ctx i = [ (v i, (ty (i - 1), true)); (x, (Obj, false)) ]
+    end)
+
+    module D = struct
+      let ps _ = Unchecked.disc 0
+      let p_src i = id2 i Args.k
+      let q_tgt i = id2 i Args.k
+      let p_inc _ = [ x_constr ]
+      let q_inc _ = [ x_constr ]
+
+      let pad_in_ps i =
+        [ (F.v i, (Construct.to_tm (id_l_id i), true)); (x, (Var x, false)) ]
+    end
   end)
 
-  module D = struct
-    let ps i = Unchecked.disc i
-    let p_src i = t_comp_id i (F.src_v (i + 1))
-    let q_tgt i = p_src i
-    let p_inc i = [ (Var (Var.Db (2 * i)), Unchecked.disc_type i) ]
-    let q_inc i = [ (Var (Var.Db ((2 * i) + 1)), Unchecked.disc_type i) ]
-    let pad_in_ps i = Unchecked.(identity (ps_to_ctx (ps i)))
-  end
-end)
-
-module BackwardBiasedPadding (Args : BiasedPaddingArgsS) =
-Padding.Padding.MakeCanonical (struct
-  let name = "BPad"
-
-  module F = Padding.Filtration.Make (struct
-    let min = 1
-    let max = Args.n
-    let ty_v i = Construct.arr (t_comp_id i (d_src i)) (t_comp_id i (d_tgt i))
-    let v i = Var.Db (2 * i)
-    let ctx i = (v i, (ty_v (i - 1), true)) :: Unchecked.sphere (i - 1)
+  (* Find a good place for these *)
+  let d_src i = (Var (Var.Db (2 * i)), Unchecked.disc_type i)
+  let d_tgt i = (Var (Var.Db ((2 * i) + 1)), Unchecked.disc_type i)
+
+  let t_comp_id d t =
+    if d = 0 then t else Construct.(wcomp t 0 (id_n d (d_tgt 0)))
+
+  module ForwardBiasedPadding (Args : BiasedPaddingArgsS) =
+  Padding.Padding.MakeCanonical (struct
+    let name = "FPad"
+
+    module F = Padding.Filtration.Make (struct
+      let min = 1
+      let max = Args.n
+      let ctx i = Unchecked.ps_to_ctx (Unchecked.disc i)
+      let v i = Var.Db (2 * i)
+    end)
+
+    module D = struct
+      let ps i = Unchecked.disc i
+      let p_src i = t_comp_id i (F.src_v (i + 1))
+      let q_tgt i = p_src i
+      let p_inc i = [ (Var (Var.Db (2 * i)), Unchecked.disc_type i) ]
+      let q_inc i = [ (Var (Var.Db ((2 * i) + 1)), Unchecked.disc_type i) ]
+      let pad_in_ps i = Unchecked.(identity (ps_to_ctx (ps i)))
+    end
   end)
 
-  module D = struct
-    let ps i = Unchecked.disc i
-    let p_src i = d_src i
-    let q_tgt i = d_src i
-    let p_inc i = [ d_src i ]
-    let q_inc i = [ d_tgt i ]
-
-    let pad_in_ps i =
-      (F.v i, (Construct.to_tm (F.src_v (i + 1)), true))
-      :: Unchecked.(identity (sphere (i - 1)))
-  end
-end)
+  module BackwardBiasedPadding (Args : BiasedPaddingArgsS) =
+  Padding.Padding.MakeCanonical (struct
+    let name = "BPad"
+
+    module F = Padding.Filtration.Make (struct
+      let min = 1
+      let max = Args.n
+      let ty_v i = Construct.arr (t_comp_id i (d_src i)) (t_comp_id i (d_tgt i))
+      let v i = Var.Db (2 * i)
+      let ctx i = (v i, (ty_v (i - 1), true)) :: Unchecked.sphere (i - 1)
+    end)
+
+    module D = struct
+      let ps i = Unchecked.disc i
+      let p_src i = d_src i
+      let q_tgt i = d_src i
+      let p_inc i = [ d_src i ]
+      let q_inc i = [ d_tgt i ]
+
+      let pad_in_ps i =
+        (F.v i, (Construct.to_tm (F.src_v (i + 1)), true))
+        :: Unchecked.(identity (sphere (i - 1)))
+    end
+  end)
 
-module ForwardToUnbiasedRepadding (Args : BiasedPaddingArgsS) =
-Padding.Repadding.MakeCanonical (struct
-  let name = "FToURepad"
+  module ForwardToUnbiasedRepadding (Args : BiasedPaddingArgsS) =
+  Padding.Repadding.MakeCanonical (struct
+    let name = "FToURepad"
 
-  module EHArgs = (val args Args.n 0 (Args.n - 1) : EHArgsS)
-  module P2 = UnbiasedPadding (EHArgs)
-  module FP = ForwardBiasedPadding (Args)
+    module EHArgs = (val args Args.n 0 (Args.n - 1) : EHArgsS)
+    module P2 = UnbiasedPadding (EHArgs)
+    module FP = ForwardBiasedPadding (Args)
 
-  module M : Padding.FiltrationMorphismS = struct
-    let name = "id"
+    module M : Padding.FiltrationMorphismS = struct
+      let name = "id"
 
-    let sub i =
-      Unchecked.sub_ps_to_sub
-        (Construct.characteristic_sub_ps (P2.F.v_constr i))
-  end
+      let sub i =
+        Unchecked.sub_ps_to_sub
+          (Construct.characteristic_sub_ps (P2.F.v_constr i))
+    end
 
-  module P1 = Padding.PaddingApp (P2.F) (M) (FP)
+    module P1 = Padding.PaddingApp (P2.F) (M) (FP)
 
-  module D = struct
-    let ps _ = Br []
-    let incl _ = [ (Var (Var.Db 0), Obj) ]
-  end
-end)
+    module D = struct
+      let ps _ = Br []
+      let incl _ = [ (Var (Var.Db 0), Obj) ]
+    end
+  end)
 
-module BackwardToUnbiasedRepadding (Args : BiasedPaddingArgsS) =
-Padding.Repadding.MakeCanonical (struct
-  let name = "BToURepad"
+  module BackwardToUnbiasedRepadding (Args : BiasedPaddingArgsS) =
+  Padding.Repadding.MakeCanonical (struct
+    let name = "BToURepad"
 
-  module EHArgs = (val args Args.n (Args.n - 1) 0)
-  module P2 = UnbiasedPadding (EHArgs)
-  module BP = BackwardBiasedPadding (Args)
+    module EHArgs = (val args Args.n (Args.n - 1) 0)
+    module P2 = UnbiasedPadding (EHArgs)
+    module BP = BackwardBiasedPadding (Args)
 
-  module M : Padding.FiltrationMorphismS = struct
-    let name = "id"
+    module M : Padding.FiltrationMorphismS = struct
+      let name = "id"
 
-    let sub i =
-      let id_pt i = Construct.(to_tm (id_n i (Var (Var.Db 0), Obj))) in
-      let rec sphere_to_point i =
-        match i with
-        | -1 -> []
-        | i ->
-            (Var.Db ((2 * i) + 1), (id_pt i, false))
-            :: (Var.Db (2 * i), (id_pt i, false))
-            :: sphere_to_point (i - 1)
-      in
-      (BP.F.v i, (Var (P2.F.v i), true)) :: sphere_to_point (i - 1)
-  end
+      let sub i =
+        let id_pt i = Construct.(to_tm (id_n i (Var (Var.Db 0), Obj))) in
+        let rec sphere_to_point i =
+          match i with
+          | -1 -> []
+          | i ->
+              (Var.Db ((2 * i) + 1), (id_pt i, false))
+              :: (Var.Db (2 * i), (id_pt i, false))
+              :: sphere_to_point (i - 1)
+        in
+        (BP.F.v i, (Var (P2.F.v i), true)) :: sphere_to_point (i - 1)
+    end
 
-  module P1 = Padding.PaddingApp (P2.F) (M) (BP)
+    module P1 = Padding.PaddingApp (P2.F) (M) (BP)
 
-  module D = struct
-    let ps _ = Br []
-    let incl _ = [ (Var (Var.Db 0), Obj) ]
-  end
-end)
+    module D = struct
+      let ps _ = Br []
+      let incl _ = [ (Var (Var.Db 0), Obj) ]
+    end
+  end)
 
-module SuspUnbiasedToUnbiasedRepadding (Args : EHArgsS) =
-Padding.Repadding.MakeCanonical (struct
-  let name = "ΣUToURepad"
+  module SuspUnbiasedToUnbiasedRepadding (Args : EHArgsS) =
+  Padding.Repadding.MakeCanonical (struct
+    let name = "ΣUToURepad"
 
-  module PrevArgs = (val args (Args.n - 1) (Args.k - 1) (Args.l - 1))
+    module PrevArgs = (val args (Args.n - 1) (Args.k - 1) (Args.l - 1))
 
-  let x = Var.Db 0
-  let x_constr = (Var x, Obj)
+    let x = Var.Db 0
+    let x_constr = (Var x, Obj)
 
-  module P2 = UnbiasedPadding (Args)
-  module PrevA = UnbiasedPadding (PrevArgs)
-  module Prev = Padding.Suspend (UnbiasedPadding (PrevArgs))
+    module P2 = UnbiasedPadding (Args)
+    module PrevA = UnbiasedPadding (PrevArgs)
+    module Prev = Padding.Suspend (UnbiasedPadding (PrevArgs))
 
-  module M : Padding.FiltrationMorphismS = struct
-    let name = "Susp"
+    module M : Padding.FiltrationMorphismS = struct
+      let name = "Susp"
 
-    let sub _ =
-      let list = [ P2.v_constr; Construct.id x_constr; x_constr; x_constr ] in
-      Construct.make_sub Prev.ctx list
-  end
+      let sub _ =
+        let list = [ P2.v_constr; Construct.id x_constr; x_constr; x_constr ] in
+        Construct.make_sub Prev.ctx list
+    end
 
-  module P1 = Padding.PaddingApp (P2.F) (M) (Prev)
+    module P1 = Padding.PaddingApp (P2.F) (M) (Prev)
 
-  module D = struct
-    let ps _ = Br []
-    let incl _ = [ x_constr ]
-  end
-end)
-
-module PseudoFunctorialityUnbiasedPadding (Args : EHArgsS) = struct
-  module UP = UnbiasedPadding (Args)
-
-  let x = Var.Db 0
-  let w = Var.Db 2
-  let ty = snd UP.v_constr
-  let ctx = (w, (ty, true)) :: UP.ctx
-  let w_constr = (Var w, ty)
-  let x_constr = (Var x, Obj)
-  let v_constr = UP.v_constr
-
-  let assoc n =
-    let tree = Builtin.Comp.tree 6 in
-    let f i = Builtin.Comp.f i in
-    let ty =
-      Construct.(
-        arr
-          (wcomp (comp3 (f 1) (f 2) (f 3)) 0 (comp3 (f 4) (f 5) (f 6)))
-          (comp3 (f 1) (comp3 (f 2) (wcomp (f 3) 0 (f 4)) (f 5)) (f 6)))
-    in
-    Suspension.coh (Some n) (check_coh tree ty ("_builtin_assoc", 0, []))
-
-  let unitor n =
-    let tree = Builtin.Comp.tree 2 in
-    let f i = Builtin.Comp.f i in
-    let x i = Builtin.Comp.x i in
-    let ty =
-      Construct.(arr (comp3 (f 1) (id_n 1 (x 1)) (f 2)) (wcomp (f 1) 0 (f 2)))
-    in
-    Suspension.coh (Some n) (check_coh tree ty ("_builtin_unitor", 0, []))
+    module D = struct
+      let ps _ = Br []
+      let incl _ = [ x_constr ]
+    end
+  end)
 
-  let intch n i =
-    assert (n >= 2);
-    let ps =
-      Br [ Br []; Suspension.ps (Some (n - 2)) (Br [ Br []; Br [] ]); Br [] ]
-    in
-    let tdb i = Var (Var.Db i) in
-    let d_L = (tdb 2, Arr (Obj, tdb 0, tdb 1)) in
-    let d_R = (tdb ((2 * n) + 6), Arr (Obj, tdb 3, tdb ((2 * n) + 5))) in
-    let d_max i =
-      let rec ty k =
-        if k = 1 then Arr (Obj, tdb 1, tdb 3)
-        else Arr (ty (k - 1), tdb (2 * k), tdb ((2 * k) + 1))
+  module PseudoFunctorialityUnbiasedPadding (Args : EHArgsS) = struct
+    module UP = UnbiasedPadding (Args)
+
+    let x = Var.Db 0
+    let w = Var.Db 2
+    let ty = snd UP.v_constr
+    let ctx = (w, (ty, true)) :: UP.ctx
+    let w_constr = (Var w, ty)
+    let x_constr = (Var x, Obj)
+    let v_constr = UP.v_constr
+
+    let assoc n =
+      let tree = Comp.tree 6 in
+      let f i = Comp.f i in
+      let ty =
+        Construct.(
+          arr
+            (wcomp (comp3 (f 1) (f 2) (f 3)) 0 (comp3 (f 4) (f 5) (f 6)))
+            (comp3 (f 1) (comp3 (f 2) (wcomp (f 3) 0 (f 4)) (f 5)) (f 6)))
       in
-      let d i =
-        let lvl = if i = 0 then 2 * n else (2 * n) + (2 * i) - 1 in
-        (tdb lvl, ty (n - 1))
+      Suspension.coh (Some n) (check_coh tree ty ("_builtin_assoc", 0, []))
+
+    let unitor n =
+      let tree = Comp.tree 2 in
+      let f i = Comp.f i in
+      let x i = Comp.x i in
+      let ty =
+        Construct.(arr (comp3 (f 1) (id_n 1 (x 1)) (f 2)) (wcomp (f 1) 0 (f 2)))
       in
-      (tdb ((2 * n) + (2 * i)), Construct.arr (d (i - 1)) (d i))
-    in
-    let ty =
-      Construct.(
-        arr
-          (comp
-             (wcomp_n 0 [ d_L; d_max 1; d_R ])
-             (wcomp_n 0 [ d_L; d_max 2; d_R ]))
-          (wcomp_n 0 [ d_L; comp_n [ d_max 1; d_max 2 ]; d_R ]))
-    in
-    Suspension.coh (Some i)
-      (check_coh ps ty ("_builtin_intch_chi" ^ string_of_int n, 0, []))
-
-  let rec psfpad_aux i =
-    let m = UP.F.min in
-    let n = UP.F.max in
-    let v_c = v_constr in
-    let w_c = w_constr in
-    let w_sub = [ w_constr; x_constr ] in
-    let witness_constr =
-      match i with
-      | i when i = m -> Construct.id_n 1 (Construct.wcomp v_c (n - 1) w_c)
-      | i when m < i -> (
-          let p, q = (UP.D.p (i - 1), UP.D.q (i - 1)) in
-          let p, q = (Tm.constr p, Tm.constr q) in
-          let t = UP.padded_func (i - 1) (n - i + 1) in
-          let tv = Tm.constr t in
-          let tw = Construct.tm_app t w_sub in
-          match i with
-          | i when i < n ->
-              let intch =
-                Construct.coh_app (intch (n - i + 1) (i - 1)) [ p; tv; tw; q ]
-              in
-              Construct.wcomp intch n
-                (Construct.wcomp_n (i - 1)
-                   [ p; Tm.constr (psfpad_aux (i - 1)); q ])
-          | i when i = n ->
-              let assoc =
-                Construct.coh_app (assoc (n - 1)) [ p; tv; q; p; tw; q ]
-              in
-              let w = Construct.witness q in
-              let unitor = Construct.coh_app (unitor (n - 1)) [ tv; tw ] in
-              Construct.comp_n
-                [
-                  assoc;
-                  Construct.wcomp_n (n - 1)
-                    [ p; Construct.wcomp_n (n - 1) [ tv; w; tw ]; q ];
-                  Construct.wcomp_n (n - 1) [ p; unitor; q ];
-                  Construct.wcomp_n (n - 1)
-                    [ p; Tm.constr (psfpad_aux (n - 1)); q ];
-                ]
-          | _ ->
-              Error.fatal
-                "[EH] Wrong arguments in pseudofunctoriality of padding")
-      | _ ->
-          Error.fatal "[EH] Wrong arguments in pseudofunctoriality of padding"
-    in
-    check_constr ctx witness_constr
+      Suspension.coh (Some n) (check_coh tree ty ("_builtin_unitor", 0, []))
 
-  let psfpad = psfpad_aux Args.n
-end
-
-module EHCtx (EHArgs : EHArgsS) = struct
-  let x = Var.Db 0
-  let a = Var.Db 1
-  let b = Var.Db 2
-  let id = Construct.id_n (EHArgs.n - 1) (Var x, Obj)
-  let ty = Construct.arr id id
-  let ctx = [ (b, (ty, true)); (a, (ty, true)); (x, (Obj, false)) ]
-  let x_constr = (Var x, Obj)
-  let a_constr = (Var a, ty)
-  let b_constr = (Var b, ty)
-
-  let a_comp_id =
-    if EHArgs.l = EHArgs.n - 1 then a_constr
-    else Construct.wcomp a_constr EHArgs.l (Construct.id_n 1 id)
-
-  let id_comp_b =
-    if EHArgs.l = EHArgs.n - 1 then b_constr
-    else Construct.wcomp (Construct.id_n 1 id) EHArgs.l b_constr
-
-  module UP = UnbiasedPadding (EHArgs)
-
-  let a_comp_id_sub = [ a_comp_id; x_constr ]
-  let id_comp_b_sub = [ id_comp_b; x_constr ]
-end
-
-module BaseCases (EHArgs : EHArgsS) = struct
-  let intch n =
-    let ps = Br [ Unchecked.disc (n - 1); Unchecked.disc (n - 1) ] in
-    let rec disc_type_r = function
-      | 0 -> Obj
-      | 1 -> Arr (Obj, Var (Var.Db 1), Var (Var.Db ((2 * n) + 1)))
-      | k ->
-          Arr
-            ( disc_type_r (k - 1),
-              Var (Var.Db ((2 * n) + (2 * k) - 2)),
-              Var (Var.Db ((2 * n) + (2 * k) - 1)) )
-    in
-    let d_l = (Var (Var.Db (2 * n)), Unchecked.disc_type n) in
-    let d_r = (Var (Var.Db (4 * n)), disc_type_r n) in
-    let ty =
-      Construct.arr
-        (Construct.wcomp
-           (Construct.wcomp d_l 0 (Construct.id_n 1 (Construct.src 1 d_r)))
-           (n - 1)
-           (Construct.wcomp (Construct.id_n 1 (Construct.tgt 1 d_l)) 0 d_r))
-        (Construct.wcomp d_l 0 d_r)
-    in
-    let name = (Printf.sprintf "intch(%d,%d)" n 0, 0, []) in
-    check_coh ps ty name
-
-  module GT (Args : BiasedPaddingArgsS) = struct
-    module BP = BackwardBiasedPadding (Args)
-    module BToU = BackwardToUnbiasedRepadding (Args)
-    module PSU = PseudoFunctorialityUnbiasedPadding (EHArgs)
-
-    let eh =
-      let open EHCtx (EHArgs) in
-      let step1 =
-        let p = BP.p in
-        let a_padded =
-          Construct.(
-            tm_app_sub p
-              (Unchecked.sub_ps_to_sub (characteristic_sub_ps a_constr)))
+    let intch n i =
+      assert (n >= 2);
+      let ps =
+        Br [ Br []; Suspension.ps (Some (n - 2)) (Br [ Br []; Br [] ]); Br [] ]
+      in
+      let tdb i = Var (Var.Db i) in
+      let d_L = (tdb 2, Arr (Obj, tdb 0, tdb 1)) in
+      let d_R = (tdb ((2 * n) + 6), Arr (Obj, tdb 3, tdb ((2 * n) + 5))) in
+      let d_max i =
+        let rec ty k =
+          if k = 1 then Arr (Obj, tdb 1, tdb 3)
+          else Arr (ty (k - 1), tdb (2 * k), tdb ((2 * k) + 1))
         in
-        let b_padded =
-          Construct.(
-            tm_app_sub
-              (Opposite.checked_tm p [ 1 ])
-              (Unchecked.sub_ps_to_sub (characteristic_sub_ps b_constr)))
+        let d i =
+          let lvl = if i = 0 then 2 * n else (2 * n) + (2 * i) - 1 in
+          (tdb lvl, ty (n - 1))
         in
-        (* TODO: there should be a fix here so that there is no need for the develop *)
-        Construct.(develop (wcomp a_padded (Args.n - 1) b_padded))
+        (tdb ((2 * n) + (2 * i)), Construct.arr (d (i - 1)) (d i))
       in
-      let step2 =
-        let r = BToU.repadded in
-        let r_op = Opposite.checked_tm r [ 1 ] in
-        let repad_a = Construct.tm_app r a_comp_id_sub in
-        let repad_b = Construct.tm_app r_op id_comp_b_sub in
-        Construct.wcomp repad_a (Args.n - 1) repad_b
+      let ty =
+        Construct.(
+          arr
+            (comp
+               (wcomp_n 0 [ d_L; d_max 1; d_R ])
+               (wcomp_n 0 [ d_L; d_max 2; d_R ]))
+            (wcomp_n 0 [ d_L; comp_n [ d_max 1; d_max 2 ]; d_R ]))
       in
-      let step3 =
-        Construct.tm_app PSU.psfpad [ id_comp_b; a_comp_id; x_constr ]
+      Suspension.coh (Some i)
+        (check_coh ps ty ("_builtin_intch_chi" ^ string_of_int n, 0, []))
+
+    let rec psfpad_aux i =
+      let m = UP.F.min in
+      let n = UP.F.max in
+      let v_c = v_constr in
+      let w_c = w_constr in
+      let w_sub = [ w_constr; x_constr ] in
+      let witness_constr =
+        match i with
+        | i when i = m -> Construct.id_n 1 (Construct.wcomp v_c (n - 1) w_c)
+        | i when m < i -> (
+            let p, q = (UP.D.p (i - 1), UP.D.q (i - 1)) in
+            let p, q = (Tm.constr p, Tm.constr q) in
+            let t = UP.padded_func (i - 1) (n - i + 1) in
+            let tv = Tm.constr t in
+            let tw = Construct.tm_app t w_sub in
+            match i with
+            | i when i < n ->
+                let intch =
+                  Construct.coh_app (intch (n - i + 1) (i - 1)) [ p; tv; tw; q ]
+                in
+                Construct.wcomp intch n
+                  (Construct.wcomp_n (i - 1)
+                     [ p; Tm.constr (psfpad_aux (i - 1)); q ])
+            | i when i = n ->
+                let assoc =
+                  Construct.coh_app (assoc (n - 1)) [ p; tv; q; p; tw; q ]
+                in
+                let w = Construct.witness q in
+                let unitor = Construct.coh_app (unitor (n - 1)) [ tv; tw ] in
+                Construct.comp_n
+                  [
+                    assoc;
+                    Construct.wcomp_n (n - 1)
+                      [ p; Construct.wcomp_n (n - 1) [ tv; w; tw ]; q ];
+                    Construct.wcomp_n (n - 1) [ p; unitor; q ];
+                    Construct.wcomp_n (n - 1)
+                      [ p; Tm.constr (psfpad_aux (n - 1)); q ];
+                  ]
+            | _ ->
+                Error.fatal
+                  "[EH] Wrong arguments in pseudofunctoriality of padding")
+        | _ ->
+            Error.fatal "[EH] Wrong arguments in pseudofunctoriality of padding"
       in
-      let step4 =
-        let intch = Construct.coh_app (intch Args.n) [ a_constr; b_constr ] in
-        Construct.tm_app
-          (Functorialisation.tm UP.padded [ (UP.v, 1) ])
-          [ intch; Construct.tgt 1 intch; Construct.src 1 intch; x_constr ]
+      check_constr ctx witness_constr
+
+    let psfpad = psfpad_aux Args.n
+  end
+
+  module EHCtx (EHArgs : EHArgsS) = struct
+    let x = Var.Db 0
+    let a = Var.Db 1
+    let b = Var.Db 2
+    let id = Construct.id_n (EHArgs.n - 1) (Var x, Obj)
+    let ty = Construct.arr id id
+    let ctx = [ (b, (ty, true)); (a, (ty, true)); (x, (Obj, false)) ]
+    let x_constr = (Var x, Obj)
+    let a_constr = (Var a, ty)
+    let b_constr = (Var b, ty)
+
+    let a_comp_id =
+      if EHArgs.l = EHArgs.n - 1 then a_constr
+      else Construct.wcomp a_constr EHArgs.l (Construct.id_n 1 id)
+
+    let id_comp_b =
+      if EHArgs.l = EHArgs.n - 1 then b_constr
+      else Construct.wcomp (Construct.id_n 1 id) EHArgs.l b_constr
+
+    module UP = UnbiasedPadding (EHArgs)
+
+    let a_comp_id_sub = [ a_comp_id; x_constr ]
+    let id_comp_b_sub = [ id_comp_b; x_constr ]
+  end
+
+  module BaseCases (EHArgs : EHArgsS) = struct
+    let intch n =
+      let ps = Br [ Unchecked.disc (n - 1); Unchecked.disc (n - 1) ] in
+      let rec disc_type_r = function
+        | 0 -> Obj
+        | 1 -> Arr (Obj, Var (Var.Db 1), Var (Var.Db ((2 * n) + 1)))
+        | k ->
+            Arr
+              ( disc_type_r (k - 1),
+                Var (Var.Db ((2 * n) + (2 * k) - 2)),
+                Var (Var.Db ((2 * n) + (2 * k) - 1)) )
+      in
+      let d_l = (Var (Var.Db (2 * n)), Unchecked.disc_type n) in
+      let d_r = (Var (Var.Db (4 * n)), disc_type_r n) in
+      let ty =
+        Construct.arr
+          (Construct.wcomp
+             (Construct.wcomp d_l 0 (Construct.id_n 1 (Construct.src 1 d_r)))
+             (n - 1)
+             (Construct.wcomp (Construct.id_n 1 (Construct.tgt 1 d_l)) 0 d_r))
+          (Construct.wcomp d_l 0 d_r)
       in
-      Construct.comp_n [ step1; step2; step3; step4 ]
+      let name = (Printf.sprintf "intch(%d,%d)" n 0, 0, []) in
+      check_coh ps ty name
+
+    module GT (Args : BiasedPaddingArgsS) = struct
+      module BP = BackwardBiasedPadding (Args)
+      module BToU = BackwardToUnbiasedRepadding (Args)
+      module PSU = PseudoFunctorialityUnbiasedPadding (EHArgs)
+
+      let eh =
+        let open EHCtx (EHArgs) in
+        let step1 =
+          let p = BP.p in
+          let a_padded =
+            Construct.(
+              tm_app_sub p
+                (Unchecked.sub_ps_to_sub (characteristic_sub_ps a_constr)))
+          in
+          let b_padded =
+            Construct.(
+              tm_app_sub
+                (Opposite.checked_tm p [ 1 ])
+                (Unchecked.sub_ps_to_sub (characteristic_sub_ps b_constr)))
+          in
+          (* TODO: there should be a fix here so that there is no need for the develop *)
+          Construct.(develop (wcomp a_padded (Args.n - 1) b_padded))
+        in
+        let step2 =
+          let r = BToU.repadded in
+          let r_op = Opposite.checked_tm r [ 1 ] in
+          let repad_a = Construct.tm_app r a_comp_id_sub in
+          let repad_b = Construct.tm_app r_op id_comp_b_sub in
+          Construct.wcomp repad_a (Args.n - 1) repad_b
+        in
+        let step3 =
+          Construct.tm_app PSU.psfpad [ id_comp_b; a_comp_id; x_constr ]
+        in
+        let step4 =
+          let intch = Construct.coh_app (intch Args.n) [ a_constr; b_constr ] in
+          Construct.tm_app
+            (Functorialisation.tm UP.padded [ (UP.v, 1) ])
+            [ intch; Construct.tgt 1 intch; Construct.src 1 intch; x_constr ]
+        in
+        Construct.comp_n [ step1; step2; step3; step4 ]
+    end
+
+    module LT (Args : BiasedPaddingArgsS) = struct
+      module FP = ForwardBiasedPadding (Args)
+      module FToU = ForwardToUnbiasedRepadding (Args)
+      module PSU = PseudoFunctorialityUnbiasedPadding (EHArgs)
+
+      let eh =
+        let open EHCtx (EHArgs) in
+        let a_sub =
+          Unchecked.sub_ps_to_sub (Construct.characteristic_sub_ps a_constr)
+        in
+        let b_sub =
+          Unchecked.sub_ps_to_sub (Construct.characteristic_sub_ps b_constr)
+        in
+        let step1 =
+          Construct.inverse
+            (Construct.coh_app (intch Args.n) [ a_constr; b_constr ])
+        in
+        let step2 =
+          let p = FP.p in
+          let a_padded = Construct.tm_app_sub p a_sub in
+          let b_padded =
+            Construct.(tm_app_sub (Opposite.checked_tm p [ 1 ]) b_sub)
+          in
+          Construct.(develop (wcomp a_padded (Args.n - 1) b_padded))
+        in
+        let step3 =
+          let r = FToU.repadded in
+          let r_op = Opposite.checked_tm r [ 1 ] in
+          let repad_a = Construct.tm_app r [ a_constr; x_constr ] in
+          let repad_b = Construct.tm_app r_op [ b_constr; x_constr ] in
+          Construct.wcomp repad_a (Args.n - 1) repad_b
+        in
+        let step4 =
+          Construct.tm_app PSU.psfpad [ b_constr; a_constr; x_constr ]
+        in
+        Construct.comp_n [ step1; step2; step3; step4 ]
+    end
   end
 
-  module LT (Args : BiasedPaddingArgsS) = struct
-    module FP = ForwardBiasedPadding (Args)
-    module FToU = ForwardToUnbiasedRepadding (Args)
-    module PSU = PseudoFunctorialityUnbiasedPadding (EHArgs)
+  let suspend eh_prev curargs =
+    let module EHArgs = (val curargs : EHArgsS) in
+    let open EHCtx (EHArgs) in
+    let module R = SuspUnbiasedToUnbiasedRepadding (EHArgs) in
+    let suspended_eh = Suspension.checked_tm (Some 1) eh_prev in
+    Construct.comp_n
+      [
+        Construct.tm_app suspended_eh
+          [ b_constr; a_constr; Construct.id x_constr; x_constr; x_constr ];
+        Construct.tm_app R.repadded
+          [ Construct.wcomp a_constr EHArgs.l b_constr; x_constr ];
+      ]
 
-    let eh =
+  module Naturality = struct
+    let nat_unitor constr =
+      let x_constr = (Var (Var.Db 0), Obj) in
+      let y_constr = (Var (Var.Db 1), Obj) in
+      let f_constr = (Var (Var.Db 2), Construct.arr x_constr y_constr) in
+      let cohty =
+        Construct.arr f_constr
+          (Construct.comp_n [ f_constr; Construct.id_n 1 y_constr ])
+      in
+      let runit = check_coh (Unchecked.disc 1) cohty ("_ehnat_step1", 0, []) in
+      let d = Construct.dim constr in
+      let sub = Construct.characteristic_sub_ps constr in
+      ( Coh (Suspension.coh (Some (d - 1)) runit, sub),
+        Unchecked.ty_apply_sub_ps (Suspension.ty (Some (d - 1)) cohty) sub )
+
+    let nat_factor eh_id_id ehargs =
+      let module EHArgs = (val ehargs : EHArgsS) in
       let open EHCtx (EHArgs) in
-      let a_sub =
-        Unchecked.sub_ps_to_sub (Construct.characteristic_sub_ps a_constr)
+      let idn = Construct.id id in
+      let ty =
+        Construct.arr
+          (Construct.id (Construct.wcomp idn EHArgs.k idn))
+          (Construct.comp_n [ eh_id_id; Tm.constr UP.q ])
       in
-      let b_sub =
-        Unchecked.sub_ps_to_sub (Construct.characteristic_sub_ps b_constr)
+
+      let name =
+        (Printf.sprintf "_factor_id(%d,%d,%d)" EHArgs.n EHArgs.k EHArgs.l, 0, [])
       in
-      let step1 =
-        Construct.inverse
-          (Construct.coh_app (intch Args.n) [ a_constr; b_constr ])
+      let coh = check_coh (Unchecked.disc 0) ty name in
+      Construct.of_coh coh
+
+    let nat_associator1 c1 c2 c3 =
+      let open Comp in
+      let ty =
+        Construct.arr
+          (Construct.comp_n [ f 1; Construct.comp_n [ f 2; f 3 ] ])
+          (Construct.comp_n [ Construct.comp_n [ f 1; f 2 ]; f 3 ])
       in
-      let step2 =
-        let p = FP.p in
-        let a_padded = Construct.tm_app_sub p a_sub in
-        let b_padded =
-          Construct.(tm_app_sub (Opposite.checked_tm p [ 1 ]) b_sub)
-        in
-        Construct.(develop (wcomp a_padded (Args.n - 1) b_padded))
+      let coh = check_coh (tree 3) ty ("_assoc_left", 0, []) in
+      let d = Construct.dim c1 in
+      Construct.coh_app (Suspension.coh (Some (d - 1)) coh) [ c1; c2; c3 ]
+
+    let nat_associator2 c1 c2 c3 =
+      let open Comp in
+      let ty =
+        Construct.arr
+          (Construct.comp_n [ Construct.comp_n [ f 1; f 2 ]; f 3 ])
+          (Construct.comp_n [ f 1; f 2; f 3 ])
+      in
+      let coh = check_coh (tree 3) ty ("_unbiasor_left", 0, []) in
+      let d = Construct.dim c1 in
+      Construct.coh_app (Suspension.coh (Some (d - 1)) coh) [ c1; c2; c3 ]
+
+    let nat_finalcoh eh_id_id ehargs =
+      let module EHArgs = (val ehargs : EHArgsS) in
+      let open EHCtx (EHArgs) in
+      let module UP = UnbiasedPadding (EHArgs) in
+      let p = Tm.constr UP.p in
+      let ty = Construct.arr eh_id_id p in
+      let name =
+        (Printf.sprintf "_eh_to_p(%d,%d,%d)" EHArgs.n EHArgs.k EHArgs.l, 0, [])
       in
-      let step3 =
-        let r = FToU.repadded in
-        let r_op = Opposite.checked_tm r [ 1 ] in
-        let repad_a = Construct.tm_app r [ a_constr; x_constr ] in
-        let repad_b = Construct.tm_app r_op [ b_constr; x_constr ] in
-        Construct.wcomp repad_a (Args.n - 1) repad_b
+      let coh = check_coh (Unchecked.disc 0) ty name in
+      Construct.of_coh coh
+
+    let compute eh_prev prev_args args =
+      let module PrevArgs = (val prev_args : EHArgsS) in
+      let open PrevArgs in
+      let module NextArgs = (val args : EHArgsS) in
+      let open EHCtx (NextArgs) in
+      let module Prev = EHCtx (PrevArgs) in
+      let module UP = UnbiasedPadding (PrevArgs) in
+      let q = Tm.constr UP.q in
+      let a_k_b = Construct.wcomp a_constr k b_constr in
+      let nat =
+        Construct.inverse
+          (Construct.tm_app
+             (Functorialisation.tm eh_prev [ (Prev.b, 1); (Prev.a, 1) ])
+             [ b_constr; id; id; a_constr; id; id; x_constr ])
       in
-      let step4 =
-        Construct.tm_app PSU.psfpad [ b_constr; a_constr; x_constr ]
+      let paddedfunc =
+        Construct.tm_app
+          (Functorialisation.tm UP.padded [ (UP.v, 1) ])
+          [
+            Construct.wcomp a_constr l b_constr;
+            UP.F.tgt_v (n + 1);
+            UP.F.src_v (n + 1);
+            x_constr;
+          ]
       in
-      Construct.comp_n [ step1; step2; step3; step4 ]
+      let eh_id_id = Construct.tm_app eh_prev [ id; id; x_constr ] in
+      Construct.comp_n
+        [
+          nat_unitor a_k_b;
+          Construct.wcomp a_k_b n (nat_factor eh_id_id prev_args);
+          nat_associator1 a_k_b eh_id_id q;
+          Construct.wcomp nat n q;
+          nat_associator2 eh_id_id paddedfunc q;
+          Construct.wcomp3 (nat_finalcoh eh_id_id prev_args) n paddedfunc n q;
+        ]
   end
-end
 
-let suspend eh_prev curargs =
-  let module EHArgs = (val curargs : EHArgsS) in
-  let open EHCtx (EHArgs) in
-  let module R = SuspUnbiasedToUnbiasedRepadding (EHArgs) in
-  let suspended_eh = Suspension.checked_tm (Some 1) eh_prev in
-  Construct.comp_n
-    [
-      Construct.tm_app suspended_eh
-        [ b_constr; a_constr; Construct.id x_constr; x_constr; x_constr ];
-      Construct.tm_app R.repadded
-        [ Construct.wcomp a_constr EHArgs.l b_constr; x_constr ];
-    ]
-
-module Naturality = struct
-  let nat_unitor constr =
-    let x_constr = (Var (Var.Db 0), Obj) in
-    let y_constr = (Var (Var.Db 1), Obj) in
-    let f_constr = (Var (Var.Db 2), Construct.arr x_constr y_constr) in
-    let cohty =
-      Construct.arr f_constr
-        (Construct.comp_n [ f_constr; Construct.id_n 1 y_constr ])
+  let rec eh nkl =
+    let module EHArgs = (val nkl : EHArgsS) in
+    let open EHArgs in
+    let module BArgs = (val args_biased n) in
+    let eh_constr =
+      if k = 0 && l = n - 1 then
+        let module BaseCases = BaseCases (EHArgs) in
+        let module BaseCase = BaseCases.LT (BArgs) in
+        BaseCase.eh
+      else if k = n - 1 && l = 0 then
+        let module BaseCases = BaseCases (EHArgs) in
+        let module BaseCase = BaseCases.GT (BArgs) in
+        BaseCase.eh
+      else if max k l = n - 1 then
+        let prevargs = args (n - 1) (k - 1) (l - 1) in
+        suspend (eh prevargs) nkl
+      else
+        let prevargs = args (n - 1) k l in
+        Naturality.compute (eh prevargs) prevargs nkl
     in
-    let runit = check_coh (Unchecked.disc 1) cohty ("_ehnat_step1", 0, []) in
-    let d = Construct.dim constr in
-    let sub = Construct.characteristic_sub_ps constr in
-    ( Coh (Suspension.coh (Some (d - 1)) runit, sub),
-      Unchecked.ty_apply_sub_ps (Suspension.ty (Some (d - 1)) cohty) sub )
-
-  let nat_factor eh_id_id ehargs =
-    let module EHArgs = (val ehargs : EHArgsS) in
-    let open EHCtx (EHArgs) in
-    let idn = Construct.id id in
-    let ty =
-      Construct.arr
-        (Construct.id (Construct.wcomp idn EHArgs.k idn))
-        (Construct.comp_n [ eh_id_id; Tm.constr UP.q ])
-    in
-
-    let name =
-      (Printf.sprintf "_factor_id(%d,%d,%d)" EHArgs.n EHArgs.k EHArgs.l, 0, [])
-    in
-    let coh = check_coh (Unchecked.disc 0) ty name in
-    Construct.of_coh coh
-
-  let nat_associator1 c1 c2 c3 =
-    let open Builtin.Comp in
-    let ty =
-      Construct.arr
-        (Construct.comp_n [ f 1; Construct.comp_n [ f 2; f 3 ] ])
-        (Construct.comp_n [ Construct.comp_n [ f 1; f 2 ]; f 3 ])
-    in
-    let coh = check_coh (tree 3) ty ("_assoc_left", 0, []) in
-    let d = Construct.dim c1 in
-    Construct.coh_app (Suspension.coh (Some (d - 1)) coh) [ c1; c2; c3 ]
-
-  let nat_associator2 c1 c2 c3 =
-    let open Builtin.Comp in
-    let ty =
-      Construct.arr
-        (Construct.comp_n [ Construct.comp_n [ f 1; f 2 ]; f 3 ])
-        (Construct.comp_n [ f 1; f 2; f 3 ])
-    in
-    let coh = check_coh (tree 3) ty ("_unbiasor_left", 0, []) in
-    let d = Construct.dim c1 in
-    Construct.coh_app (Suspension.coh (Some (d - 1)) coh) [ c1; c2; c3 ]
-
-  let nat_finalcoh eh_id_id ehargs =
-    let module EHArgs = (val ehargs : EHArgsS) in
-    let open EHCtx (EHArgs) in
-    let module UP = UnbiasedPadding (EHArgs) in
-    let p = Tm.constr UP.p in
-    let ty = Construct.arr eh_id_id p in
-    let name =
-      (Printf.sprintf "_eh_to_p(%d,%d,%d)" EHArgs.n EHArgs.k EHArgs.l, 0, [])
-    in
-    let coh = check_coh (Unchecked.disc 0) ty name in
-    Construct.of_coh coh
-
-  let compute eh_prev prev_args args =
-    let module PrevArgs = (val prev_args : EHArgsS) in
-    let open PrevArgs in
-    let module NextArgs = (val args : EHArgsS) in
-    let open EHCtx (NextArgs) in
-    let module Prev = EHCtx (PrevArgs) in
-    let module UP = UnbiasedPadding (PrevArgs) in
-    let q = Tm.constr UP.q in
-    let a_k_b = Construct.wcomp a_constr k b_constr in
-    let nat =
-      Construct.inverse
-        (Construct.tm_app
-           (Functorialisation.tm eh_prev [ (Prev.b, 1); (Prev.a, 1) ])
-           [ b_constr; id; id; a_constr; id; id; x_constr ])
-    in
-    let paddedfunc =
-      Construct.tm_app
-        (Functorialisation.tm UP.padded [ (UP.v, 1) ])
+    let module C = EHCtx (EHArgs) in
+    check_constr C.ctx
+      ~name:(Printf.sprintf "eh^%d_(%d,%d)" n k l, 0, [])
+      eh_constr
+
+  let full_eh nkl =
+    let eh = eh nkl in
+    let open (val nkl) in
+    let open EHCtx ((val nkl)) in
+    let constr =
+      Construct.comp_n
         [
-          Construct.wcomp a_constr l b_constr;
-          UP.F.tgt_v (n + 1);
-          UP.F.src_v (n + 1);
-          x_constr;
+          Construct.of_tm eh;
+          Construct.tm_app
+            (Inverse.inverse (Opposite.checked_tm eh [ l + 1 ]))
+            [ a_constr; b_constr; x_constr ];
         ]
     in
-    let eh_id_id = Construct.tm_app eh_prev [ id; id; x_constr ] in
-    Construct.comp_n
-      [
-        nat_unitor a_k_b;
-        Construct.wcomp a_k_b n (nat_factor eh_id_id prev_args);
-        nat_associator1 a_k_b eh_id_id q;
-        Construct.wcomp nat n q;
-        nat_associator2 eh_id_id paddedfunc q;
-        Construct.wcomp3 (nat_finalcoh eh_id_id prev_args) n paddedfunc n q;
-      ]
-end
+    check_constr ctx constr
 
-let rec eh nkl =
-  let module EHArgs = (val nkl : EHArgsS) in
-  let open EHArgs in
-  let module BArgs = (val args_biased n) in
-  let eh_constr =
-    if k = 0 && l = n - 1 then
-      let module BaseCases = BaseCases (EHArgs) in
-      let module BaseCase = BaseCases.LT (BArgs) in
-      BaseCase.eh
-    else if k = n - 1 && l = 0 then
-      let module BaseCases = BaseCases (EHArgs) in
-      let module BaseCase = BaseCases.GT (BArgs) in
-      BaseCase.eh
-    else if max k l = n - 1 then
-      let prevargs = args (n - 1) (k - 1) (l - 1) in
-      suspend (eh prevargs) nkl
-    else
-      let prevargs = args (n - 1) k l in
-      Naturality.compute (eh prevargs) prevargs nkl
-  in
-  let module C = EHCtx (EHArgs) in
-  check_constr C.ctx
-    ~name:(Printf.sprintf "eh^%d_(%d,%d)" n k l, 0, [])
-    eh_constr
-
-let full_eh nkl =
-  let eh = eh nkl in
-  let open (val nkl) in
-  let open EHCtx ((val nkl)) in
-  let constr =
-    Construct.comp_n
-      [
-        Construct.of_tm eh;
-        Construct.tm_app
-          (Inverse.inverse (Opposite.checked_tm eh [ l + 1 ]))
-          [ a_constr; b_constr; x_constr ];
-      ]
-  in
-  check_constr ctx constr
-
-let eh n k l = eh (args n k l)
-let full_eh n k l = full_eh (args n k l)
+  let eh n k l = eh (args n k l)
+  let full_eh n k l = full_eh (args n k l)
+end
diff --git a/lib/meta_operations/eh.mli b/lib/meta_operations/eh.mli
index 44aab184..1115c917 100644
--- a/lib/meta_operations/eh.mli
+++ b/lib/meta_operations/eh.mli
@@ -1,4 +1,6 @@
-open Kernel
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val eh : int -> int -> int -> Tm.t
-val full_eh : int -> int -> int -> Tm.t
+  val eh : int -> int -> int -> Tm.t
+  val full_eh : int -> int -> int -> Tm.t
+end
diff --git a/lib/meta_operations/functorialisation.ml b/lib/meta_operations/functorialisation.ml
index e7f77a5a..5f0709c8 100644
--- a/lib/meta_operations/functorialisation.ml
+++ b/lib/meta_operations/functorialisation.ml
@@ -1,120 +1,126 @@
 open Common
-open Kernel
 
-exception FunctorialiseMeta
-exception NotClosed
-exception Unsupported
-
-let coh_depth1 =
-  ref (fun _ -> Error.fatal "Uninitialised forward reference coh_depth1")
-
-module Memo = struct
-  let tbl_whisk = Hashtbl.create 97
-
-  let find_whisk i f =
-    try Hashtbl.find tbl_whisk i
-    with Not_found ->
-      let res = f i in
-      Hashtbl.add tbl_whisk i res;
-      res
-end
-
-let check_upwards_closed ctx l =
-  let closed =
-    List.for_all
-      (fun x ->
-        List.for_all
-          (fun (y, (ty, _)) ->
-            (not (Unchecked.ty_contains_var ty x)) || List.mem y l)
-          ctx)
-      l
-  in
-  if not closed then raise NotClosed
-
-let check_codim1 c n l =
-  let is_comdim1 =
-    List.for_all
-      (fun x ->
-        let ty, _ = List.assoc x c in
-        Unchecked.dim_ty ty >= n - 1)
-      l
-  in
-  if not is_comdim1 then raise Unsupported
-
-let rec next_round l =
-  match l with
-  | [] -> ([], [])
-  | (_, 0) :: l ->
-      let vars, left = next_round l in
-      (vars, left)
-  | (v, n) :: l when n >= 1 ->
-      let vars, left = next_round l in
-      (v :: vars, (Var.Bridge v, n - 1) :: left)
-  | _ -> Error.fatal "cannot functorialise a negative number of times."
-
-(* Functorialised coherences with respect to locally maximal variables are
-   coherences. This function updates the list of variables in the resulting
-   coherence that come from a functorialisation *)
-let pp_data l (name, susp, func) =
-  let func =
-    let is_mergeable =
-      match func with
-      | [] -> false
-      | f :: _ ->
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Comp = Comp.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+
+  exception FunctorialiseMeta
+  exception NotClosed
+  exception Unsupported
+
+  let coh_depth1 =
+    ref (fun _ -> Error.fatal "Uninitialised forward reference coh_depth1")
+
+  module Memo = struct
+    let tbl_whisk = Hashtbl.create 97
+
+    let find_whisk i f =
+      try Hashtbl.find tbl_whisk i
+      with Not_found ->
+        let res = f i in
+        Hashtbl.add tbl_whisk i res;
+        res
+  end
+
+  let check_upwards_closed ctx l =
+    let closed =
+      List.for_all
+        (fun x ->
           List.for_all
-            (fun x ->
-              match List.assoc_opt x f with
-              | None -> false
-              | Some k -> List.for_all (fun (_, n) -> n <= k) f)
-            l
+            (fun (y, (ty, _)) ->
+              (not (Unchecked.ty_contains_var ty x)) || List.mem y l)
+            ctx)
+        l
     in
-    if is_mergeable then
-      let f, func =
-        match func with [] -> assert false | f :: func -> (f, func)
-      in
-      let rec add_in func v =
+    if not closed then raise NotClosed
+
+  let check_codim1 c n l =
+    let is_comdim1 =
+      List.for_all
+        (fun x ->
+          let ty, _ = List.assoc x c in
+          Unchecked.dim_ty ty >= n - 1)
+        l
+    in
+    if not is_comdim1 then raise Unsupported
+
+  let rec next_round l =
+    match l with
+    | [] -> ([], [])
+    | (_, 0) :: l ->
+        let vars, left = next_round l in
+        (vars, left)
+    | (v, n) :: l when n >= 1 ->
+        let vars, left = next_round l in
+        (v :: vars, (Var.Bridge v, n - 1) :: left)
+    | _ -> Error.fatal "cannot functorialise a negative number of times."
+
+  (* Functorialised coherences with respect to locally maximal variables are
+   coherences. This function updates the list of variables in the resulting
+   coherence that come from a functorialisation *)
+  let pp_data l (name, susp, func) =
+    let func =
+      let is_mergeable =
         match func with
-        | [] -> [ (Var.Bridge v, 1) ]
-        | (w, n) :: func when v = w -> (Var.Bridge v, n + 1) :: func
-        | (w, n) :: func -> (w, n) :: add_in func v
+        | [] -> false
+        | f :: _ ->
+            List.for_all
+              (fun x ->
+                match List.assoc_opt x f with
+                | None -> false
+                | Some k -> List.for_all (fun (_, n) -> n <= k) f)
+              l
       in
-      let rec add_all func l =
-        match l with [] -> func | v :: l -> add_all (add_in func v) l
-      in
-      add_all f l :: func
-    else List.map (fun x -> (Var.Bridge x, 1)) l :: func
-  in
-  (name, susp, func)
+      if is_mergeable then
+        let f, func =
+          match func with [] -> assert false | f :: func -> (f, func)
+        in
+        let rec add_in func v =
+          match func with
+          | [] -> [ (Var.Bridge v, 1) ]
+          | (w, n) :: func when v = w -> (Var.Bridge v, n + 1) :: func
+          | (w, n) :: func -> (w, n) :: add_in func v
+        in
+        let rec add_all func l =
+          match l with [] -> func | v :: l -> add_all (add_in func v) l
+        in
+        add_all f l :: func
+      else List.map (fun x -> (Var.Bridge x, 1)) l :: func
+    in
+    (name, susp, func)
 
-(*
+  (*
    Given a context, a ps-substitution and a list of variables, returns
    the list of all variables in the context whose corresponding term
    in the substitution contains a variable from the input list
 *)
-let rec preimage ctx s l =
-  match (ctx, s) with
-  | [], [] -> []
-  | (x, _) :: c, (t, _) :: s when Unchecked.tm_contains_vars t l ->
-      x :: preimage c s l
-  | _ :: c, _ :: s -> preimage c s l
-  | [], _ :: _ | _ :: _, [] ->
-      Error.fatal "functorialisation in a non-existant place"
-
-let rec tgt_renaming l =
-  match l with [] -> [] | v :: tl -> (v, Var (Var.Plus v)) :: tgt_renaming tl
-
-(* returns the n-composite of a (n+j)-cell with a (n+k)-cell *)
-let rec whisk n j k =
-  let build_whisk t =
-    let n, j, k = t in
-    let comp = Builtin.comp_n 2 in
-    let func_data = [ (Var.Db 4, k); (Var.Db 2, j) ] in
-    let whisk = coh_successively comp func_data in
-    Suspension.checked_tm (Some n) whisk
-  in
-  Memo.find_whisk (n, j, k) build_whisk
-
-(*
+  let rec preimage ctx s l =
+    match (ctx, s) with
+    | [], [] -> []
+    | (x, _) :: c, (t, _) :: s when Unchecked.tm_contains_vars t l ->
+        x :: preimage c s l
+    | _ :: c, _ :: s -> preimage c s l
+    | [], _ :: _ | _ :: _, [] ->
+        Error.fatal "functorialisation in a non-existant place"
+
+  let rec tgt_renaming l =
+    match l with
+    | [] -> []
+    | v :: tl -> (v, Var (Var.Plus v)) :: tgt_renaming tl
+
+  (* returns the n-composite of a (n+j)-cell with a (n+k)-cell *)
+  let rec whisk n j k =
+    let build_whisk t =
+      let n, j, k = t in
+      let comp = Comp.comp_n 2 in
+      let func_data = [ (Var.Db 4, k); (Var.Db 2, j) ] in
+      let whisk = coh_successively comp func_data in
+      Suspension.checked_tm (Some n) whisk
+    in
+    Memo.find_whisk (n, j, k) build_whisk
+
+  (*
   How long should substitutions for whisk be?
   (whisk 0 0 0) requires ps-context (x(f)y(g)z) so 2+1+1+1
   (whisk n 0 0) requires 2*(n+1)+1+1+1
@@ -123,15 +129,15 @@ let rec whisk n j k =
 
   Assuming ty1 has right dimension, we just need to know k
 *)
-and whisk_sub_ps k t1 ty1 t2 ty2 =
-  let rec take n l =
-    match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
-  in
-  let sub_base = Unchecked.ty_to_sub_ps ty1 in
-  let sub_ext = take ((2 * k) + 1) (Unchecked.ty_to_sub_ps ty2) in
-  List.concat [ [ (t2, true) ]; sub_ext; [ (t1, true) ]; sub_base ]
-
-(*
+  and whisk_sub_ps k t1 ty1 t2 ty2 =
+    let rec take n l =
+      match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
+    in
+    let sub_base = Unchecked.ty_to_sub_ps ty1 in
+    let sub_ext = take ((2 * k) + 1) (Unchecked.ty_to_sub_ps ty2) in
+    List.concat [ [ (t2, true) ]; sub_ext; [ (t1, true) ]; sub_base ]
+
+  (*
   wcomp is the whiskered binary composite
   wcomp (f,fty) n (g,gty) means f *_n g
 
@@ -140,214 +146,219 @@ and whisk_sub_ps k t1 ty1 t2 ty2 =
   This API takes and returns pairs (tm*ty) meaning it can be easily nested
   (wcomp f 0 (wcomp g 0 h)) = f *_0 (g *_0 h)
 *)
-and wcomp (f, fty) n (g, gty) =
-  let j = Unchecked.dim_ty fty - n - 1 in
-  let k = Unchecked.dim_ty gty - n - 1 in
-  let whisk = whisk n j k in
-  let whisk_sub_ps = whisk_sub_ps k f fty g gty in
-  let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-  (App (whisk, whisk_sub), Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps)
-
-(* Invariant maintained:
+  and wcomp (f, fty) n (g, gty) =
+    let j = Unchecked.dim_ty fty - n - 1 in
+    let k = Unchecked.dim_ty gty - n - 1 in
+    let whisk = whisk n j k in
+    let whisk_sub_ps = whisk_sub_ps k f fty g gty in
+    let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
+    ( App (whisk, whisk_sub),
+      Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
+
+  (* Invariant maintained:
     src_prod returns a term of same dimension as tm
 *)
-and src_prod t l tm tm_t d n =
-  match t with
-  | Arr (ty', src, _tgt) when Unchecked.tm_contains_vars src l ->
-      let prod = src_prod ty' l tm tm_t d (n - 1) in
-      let ty_f = ty ty' l src in
-      let src_f = tm_one_step_tm src l in
-      wcomp (src_f, ty_f) n prod
-  | Arr (_, _, _) | Obj -> (tm, tm_t)
-  | _ -> raise FunctorialiseMeta
-
-and tgt_prod t l tm tm_t d n =
-  match t with
-  | Arr (ty', _src, tgt) when Unchecked.tm_contains_vars tgt l ->
-      let prod = tgt_prod ty' l tm tm_t d (n - 1) in
-      let ty_f = ty ty' l tgt in
-      let tgt_f = tm_one_step_tm tgt l in
-      wcomp prod n (tgt_f, ty_f)
-  | Arr (_, _, _) | Obj -> (tm, tm_t)
-  | _ -> raise FunctorialiseMeta
-
-and ty t l tm =
-  let d = Unchecked.dim_ty t in
-  let tgt_renaming = tgt_renaming l in
-  let tm_incl = Unchecked.tm_rename tm tgt_renaming in
-  let t_incl = Unchecked.ty_rename t tgt_renaming in
-  let src, src_t = tgt_prod t l tm t d (d - 1) in
-  let tgt, _tgt_t = src_prod t l tm_incl t_incl d (d - 1) in
-  Arr (src_t, src, tgt)
-
-and ctx c l =
-  match c with
-  | [] -> []
-  | (x, (t, expl)) :: c when List.mem x l ->
-      let ty_tgt = Unchecked.ty_rename t (tgt_renaming l) in
-      let tf = ty t l (Var x) in
-      (Var.Bridge x, (tf, expl))
-      :: (Var.Plus x, (ty_tgt, false))
-      :: (x, (t, false))
-      :: ctx c l
-  | (x, a) :: c -> (x, a) :: ctx c l
-
-(* Functorialisation of a coherence once with respect to a list of
+  and src_prod t l tm tm_t d n =
+    match t with
+    | Arr (ty', src, _tgt) when Unchecked.tm_contains_vars src l ->
+        let prod = src_prod ty' l tm tm_t d (n - 1) in
+        let ty_f = ty ty' l src in
+        let src_f = tm_one_step_tm src l in
+        wcomp (src_f, ty_f) n prod
+    | Arr (_, _, _) | Obj -> (tm, tm_t)
+    | _ -> raise FunctorialiseMeta
+
+  and tgt_prod t l tm tm_t d n =
+    match t with
+    | Arr (ty', _src, tgt) when Unchecked.tm_contains_vars tgt l ->
+        let prod = tgt_prod ty' l tm tm_t d (n - 1) in
+        let ty_f = ty ty' l tgt in
+        let tgt_f = tm_one_step_tm tgt l in
+        wcomp prod n (tgt_f, ty_f)
+    | Arr (_, _, _) | Obj -> (tm, tm_t)
+    | _ -> raise FunctorialiseMeta
+
+  and ty t l tm =
+    let d = Unchecked.dim_ty t in
+    let tgt_renaming = tgt_renaming l in
+    let tm_incl = Unchecked.tm_rename tm tgt_renaming in
+    let t_incl = Unchecked.ty_rename t tgt_renaming in
+    let src, src_t = tgt_prod t l tm t d (d - 1) in
+    let tgt, _tgt_t = src_prod t l tm_incl t_incl d (d - 1) in
+    Arr (src_t, src, tgt)
+
+  and ctx c l =
+    match c with
+    | [] -> []
+    | (x, (t, expl)) :: c when List.mem x l ->
+        let ty_tgt = Unchecked.ty_rename t (tgt_renaming l) in
+        let tf = ty t l (Var x) in
+        (Var.Bridge x, (tf, expl))
+        :: (Var.Plus x, (ty_tgt, false))
+        :: (x, (t, false))
+        :: ctx c l
+    | (x, a) :: c -> (x, a) :: ctx c l
+
+  (* Functorialisation of a coherence once with respect to a list of
    variables *)
-and coh_depth0 coh l =
-  let ps, _, _ = Coh.forget coh in
-  Coh.apply
-    (fun c -> ctx c l)
-    (fun t -> ty t l (Coh (coh, Unchecked.identity_ps ps)))
-    (fun pp -> pp_data l pp)
-    coh
-
-and coh coh l =
-  let ps, ty, _ = Coh.forget coh in
-  let c = Unchecked.ps_to_ctx ps in
-  check_upwards_closed c l;
-  let depth0 = List.for_all (fun (x, (_, e)) -> e || not (List.mem x l)) c in
-  if depth0 then
-    let coh, names = coh_depth0 coh l in
-    (Tm.of_coh coh, names)
-  else (
-    check_codim1 c (Unchecked.dim_ty ty) l;
-    (!coh_depth1 coh l, []))
-
-and coh_successively c l =
-  let l, next = next_round l in
-  if l = [] then
-    let ps, _, name = Coh.forget c in
-    let id = Unchecked.identity_ps ps in
-    check_term (Ctx.check (Unchecked.ps_to_ctx ps)) ~name (Coh (c, id))
-  else
-    let cohf, names = coh c l in
-    let next =
-      List.map (fun (x, i) -> (Display_maps.var_apply_sub x names, i)) next
-    in
-    tm_successively cohf next
+  and coh_depth0 coh l =
+    let ps, _, _ = Coh.forget coh in
+    Coh.apply
+      (fun c -> ctx c l)
+      (fun t -> ty t l (Coh (coh, Unchecked.identity_ps ps)))
+      (fun pp -> pp_data l pp)
+      coh
+
+  and coh coh l =
+    let ps, ty, _ = Coh.forget coh in
+    let c = Unchecked.ps_to_ctx ps in
+    check_upwards_closed c l;
+    let depth0 = List.for_all (fun (x, (_, e)) -> e || not (List.mem x l)) c in
+    if depth0 then
+      let coh, names = coh_depth0 coh l in
+      (Tm.of_coh coh, names)
+    else (
+      check_codim1 c (Unchecked.dim_ty ty) l;
+      (!coh_depth1 coh l, []))
+
+  and coh_successively c l =
+    let l, next = next_round l in
+    if l = [] then
+      let ps, _, name = Coh.forget c in
+      let id = Unchecked.identity_ps ps in
+      check_term (Ctx.check (Unchecked.ps_to_ctx ps)) ~name (Coh (c, id))
+    else
+      let cohf, names = coh c l in
+      let next =
+        List.map (fun (x, i) -> (Display_maps.var_apply_sub x names, i)) next
+      in
+      tm_successively cohf next
 
-(*
+  (*
    Functorialisation a term once with respect to a list of variables.
    Returns a list containing the functorialise term followed by its
    target and its source.
  *)
-and tm_one_step t l expl =
-  match t with
-  | Var v ->
-      [ (Var (Var.Bridge v), expl); (Var (Var.Plus v), false); (Var v, false) ]
-  | Coh (c, s) ->
-      let t' = Unchecked.tm_rename t (tgt_renaming l) in
-      let sf = sub_ps s l in
-      let ps, _, _ = Coh.forget c in
-      let psc = Unchecked.ps_to_ctx ps in
-      let places = preimage psc s l in
-      let cohf, _ = coh c places in
-      let subf = Unchecked.list_to_sub (List.map fst sf) (Tm.ctx cohf) in
-      let tm = App (cohf, subf) in
-      [ (tm, expl); (t', false); (t, false) ]
-  | App (t, s) ->
-      let total_t = Unchecked.tm_apply_sub (Tm.develop t) s in
-      tm_one_step total_t l expl
-  | Meta_tm _ -> raise FunctorialiseMeta
-
-and tm_one_step_tm t l = fst (List.hd (tm_one_step t l true))
-
-and sub_ps s l =
-  match s with
-  | [] -> []
-  | (t, expl) :: s ->
-      if not (Unchecked.tm_contains_vars t l) then (t, expl) :: sub_ps s l
-      else List.append (tm_one_step t l expl) (sub_ps s l)
-
-and tm_successively t s =
-  let l, next = next_round s in
-  if l <> [] then
-    let t, names =
-      Tm.apply
-        (fun c -> ctx c l)
-        (fun t -> tm_one_step_tm t l)
-        (fun pp -> pp_data l pp)
-        t
+  and tm_one_step t l expl =
+    match t with
+    | Var v ->
+        [
+          (Var (Var.Bridge v), expl); (Var (Var.Plus v), false); (Var v, false);
+        ]
+    | Coh (c, s) ->
+        let t' = Unchecked.tm_rename t (tgt_renaming l) in
+        let sf = sub_ps s l in
+        let ps, _, _ = Coh.forget c in
+        let psc = Unchecked.ps_to_ctx ps in
+        let places = preimage psc s l in
+        let cohf, _ = coh c places in
+        let subf = Unchecked.list_to_sub (List.map fst sf) (Tm.ctx cohf) in
+        let tm = App (cohf, subf) in
+        [ (tm, expl); (t', false); (t, false) ]
+    | App (t, s) ->
+        let total_t = Unchecked.tm_apply_sub (Tm.develop t) s in
+        tm_one_step total_t l expl
+    | Meta_tm _ -> raise FunctorialiseMeta
+
+  and tm_one_step_tm t l = fst (List.hd (tm_one_step t l true))
+
+  and sub_ps s l =
+    match s with
+    | [] -> []
+    | (t, expl) :: s ->
+        if not (Unchecked.tm_contains_vars t l) then (t, expl) :: sub_ps s l
+        else List.append (tm_one_step t l expl) (sub_ps s l)
+
+  and tm_successively t s =
+    let l, next = next_round s in
+    if l <> [] then
+      let t, names =
+        Tm.apply
+          (fun c -> ctx c l)
+          (fun t -> tm_one_step_tm t l)
+          (fun pp -> pp_data l pp)
+          t
+      in
+      tm_successively t
+        (List.map (fun (x, i) -> (Display_maps.var_apply_sub x names, i)) next)
+    else t
+
+  (* Public API *)
+  let report_errors f str =
+    try f () with
+    | FunctorialiseMeta ->
+        Error.functorialisation (Lazy.force str)
+          "cannot functorialise meta-variables"
+    | NotClosed ->
+        Error.functorialisation (Lazy.force str)
+          "list of functorialised arguments is not closed"
+    | Unsupported ->
+        Error.functorialisation (Lazy.force str)
+          "higher-dimensional transformations in depth >= 0 are not yet \
+           supported"
+
+  (* Functorialisation of a coherence: exposed function *)
+  let coh c l =
+    report_errors
+      (fun _ -> fst (coh c l))
+      (lazy ("coherence: " ^ Coh.to_string c))
+
+  let coh_depth0 c l =
+    report_errors
+      (fun _ -> fst (coh_depth0 c l))
+      (lazy ("coherence: " ^ Coh.to_string c))
+
+  let coh_successively c l =
+    report_errors
+      (fun _ -> coh_successively c l)
+      (lazy ("coherence: " ^ Coh.to_string c))
+
+  let rec sub s l =
+    match s with
+    | [] -> []
+    | (x, (t, e)) :: s when not (List.mem x l) -> (x, (t, e)) :: sub s l
+    | (x, (t, e)) :: s -> (
+        match tm_one_step t l true with
+        | [ (tm_f, _); (tgt_t, _); (src_t, _) ] ->
+            (Var.Bridge x, (tm_f, e))
+            :: (Var.Plus x, (tgt_t, false))
+            :: (x, (src_t, false))
+            :: sub s l
+        | [ (t, _) ] -> (x, (t, e)) :: sub s l
+        | _ -> assert false)
+
+  (* Functorialisation once with respect to every maximal argument *)
+  let coh_all_depth0 c =
+    let ps, _, _ = Coh.forget c in
+    let ct = Unchecked.ps_to_ctx ps in
+    let d = Unchecked.dim_ps ps in
+    let l =
+      List.filter_map
+        (fun (x, (ty, _)) -> if Unchecked.dim_ty ty = d then Some x else None)
+        ct
     in
-    tm_successively t
-      (List.map (fun (x, i) -> (Display_maps.var_apply_sub x names, i)) next)
-  else t
-
-(* Public API *)
-let report_errors f str =
-  try f () with
-  | FunctorialiseMeta ->
-      Error.functorialisation (Lazy.force str)
-        "cannot functorialise meta-variables"
-  | NotClosed ->
-      Error.functorialisation (Lazy.force str)
-        "list of functorialised arguments is not closed"
-  | Unsupported ->
-      Error.functorialisation (Lazy.force str)
-        "higher-dimensional transformations in depth >= 0 are not yet supported"
-
-(* Functorialisation of a coherence: exposed function *)
-let coh c l =
-  report_errors
-    (fun _ -> fst (coh c l))
-    (lazy ("coherence: " ^ Coh.to_string c))
-
-let coh_depth0 c l =
-  report_errors
-    (fun _ -> fst (coh_depth0 c l))
-    (lazy ("coherence: " ^ Coh.to_string c))
-
-let coh_successively c l =
-  report_errors
-    (fun _ -> coh_successively c l)
-    (lazy ("coherence: " ^ Coh.to_string c))
-
-let rec sub s l =
-  match s with
-  | [] -> []
-  | (x, (t, e)) :: s when not (List.mem x l) -> (x, (t, e)) :: sub s l
-  | (x, (t, e)) :: s -> (
-      match tm_one_step t l true with
-      | [ (tm_f, _); (tgt_t, _); (src_t, _) ] ->
-          (Var.Bridge x, (tm_f, e))
-          :: (Var.Plus x, (tgt_t, false))
-          :: (x, (src_t, false))
-          :: sub s l
-      | [ (t, _) ] -> (x, (t, e)) :: sub s l
-      | _ -> assert false)
-
-(* Functorialisation once with respect to every maximal argument *)
-let coh_all_depth0 c =
-  let ps, _, _ = Coh.forget c in
-  let ct = Unchecked.ps_to_ctx ps in
-  let d = Unchecked.dim_ps ps in
-  let l =
-    List.filter_map
-      (fun (x, (ty, _)) -> if Unchecked.dim_ty ty = d then Some x else None)
-      ct
-  in
-  coh_depth0 c l
-
-(* Functorialisation once with respect to every maximal argument *)
-let coh_all c =
-  let ps, _, _ = Coh.forget c in
-  let l = List.map fst (Unchecked.ps_to_ctx ps) in
-  coh c l
-
-(* Functorialisation a term: exposed function *)
-let tm t l =
-  report_errors
-    (fun _ -> tm_successively t l)
-    (lazy ("term: " ^ Tm.to_string t))
-
-let ps p l =
-  let c = ctx (Unchecked.ps_to_ctx p) l in
-  let _, names, _ = Unchecked.db_levels c in
-  (PS.(forget (mk (Ctx.check c))), names)
-
-let sub_w_tgt p s l =
-  let s_f = sub_ps s l in
-  let l = preimage (Unchecked.ps_to_ctx p) s l in
-  let p_f, names = ps p l in
-  (s_f, p_f, names, l)
+    coh_depth0 c l
+
+  (* Functorialisation once with respect to every maximal argument *)
+  let coh_all c =
+    let ps, _, _ = Coh.forget c in
+    let l = List.map fst (Unchecked.ps_to_ctx ps) in
+    coh c l
+
+  (* Functorialisation a term: exposed function *)
+  let tm t l =
+    report_errors
+      (fun _ -> tm_successively t l)
+      (lazy ("term: " ^ Tm.to_string t))
+
+  let ps p l =
+    let c = ctx (Unchecked.ps_to_ctx p) l in
+    let _, names, _ = Unchecked.db_levels c in
+    (PS.(forget (mk (Ctx.check c))), names)
+
+  let sub_w_tgt p s l =
+    let s_f = sub_ps s l in
+    let l = preimage (Unchecked.ps_to_ctx p) s l in
+    let p_f, names = ps p l in
+    (s_f, p_f, names, l)
+end
diff --git a/lib/meta_operations/functorialisation.mli b/lib/meta_operations/functorialisation.mli
index f59398be..987c6bbf 100644
--- a/lib/meta_operations/functorialisation.mli
+++ b/lib/meta_operations/functorialisation.mli
@@ -1,28 +1,31 @@
 open Common
-open Kernel
 
-val coh_depth1 : (Coh.t -> Var.t list -> Tm.t) ref
-val preimage : ctx -> sub_ps -> Var.t list -> Var.t list
-val tgt_renaming : Var.t list -> (Var.t * tm) list
-val coh : Coh.t -> Var.t list -> Tm.t
-val coh_successively : Coh.t -> (Var.t * int) list -> Tm.t
-val coh_depth0 : Coh.t -> Var.t list -> Coh.t
-val coh_all_depth0 : Coh.t -> Coh.t
-val coh_all : Coh.t -> Tm.t
-val tm_one_step_tm : tm -> Var.t list -> tm
-val ty : ty -> Var.t list -> tm -> ty
-val tm : Tm.t -> (Var.t * int) list -> Tm.t
-val ctx : ctx -> Var.t list -> ctx
-val sub_ps : sub_ps -> Var.t list -> sub_ps
-val ps : ps -> Var.t list -> ps * (Var.t * (int * bool)) list
-val sub : sub -> Var.t list -> sub
-val pp_data : Var.t list -> pp_data -> pp_data
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val sub_w_tgt :
-  ps ->
-  sub_ps ->
-  Var.t list ->
-  sub_ps * ps * (Var.t * (int * bool)) list * Var.t list
+  val coh_depth1 : (Coh.t -> Var.t list -> Tm.t) ref
+  val preimage : ctx -> sub_ps -> Var.t list -> Var.t list
+  val tgt_renaming : Var.t list -> (Var.t * tm) list
+  val coh : Coh.t -> Var.t list -> Tm.t
+  val coh_successively : Coh.t -> (Var.t * int) list -> Tm.t
+  val coh_depth0 : Coh.t -> Var.t list -> Coh.t
+  val coh_all_depth0 : Coh.t -> Coh.t
+  val coh_all : Coh.t -> Tm.t
+  val tm_one_step_tm : tm -> Var.t list -> tm
+  val ty : ty -> Var.t list -> tm -> ty
+  val tm : Tm.t -> (Var.t * int) list -> Tm.t
+  val ctx : ctx -> Var.t list -> ctx
+  val sub_ps : sub_ps -> Var.t list -> sub_ps
+  val ps : ps -> Var.t list -> ps * (Var.t * (int * bool)) list
+  val sub : sub -> Var.t list -> sub
+  val pp_data : Var.t list -> pp_data -> pp_data
 
-val whisk_sub_ps : int -> tm -> ty -> tm -> ty -> sub_ps
-val wcomp : tm * ty -> int -> tm * ty -> tm * ty
+  val sub_w_tgt :
+    ps ->
+    sub_ps ->
+    Var.t list ->
+    sub_ps * ps * (Var.t * (int * bool)) list * Var.t list
+
+  val whisk_sub_ps : int -> tm -> ty -> tm -> ty -> sub_ps
+  val wcomp : tm * ty -> int -> tm * ty -> tm * ty
+end
diff --git a/lib/meta_operations/inverse.ml b/lib/meta_operations/inverse.ml
index 0a01293a..ef702a25 100644
--- a/lib/meta_operations/inverse.ml
+++ b/lib/meta_operations/inverse.ml
@@ -1,253 +1,269 @@
 open Common
-open Kernel
 open Std
 
-exception NotInvertible of string
-exception CohNonInv
-
-let ty t =
-  match t with Obj | Meta_ty _ -> assert false | Arr (a, u, v) -> Arr (a, v, u)
-
-let coh c =
-  if not (Coh.is_inv c) then raise CohNonInv;
-  Coh.apply_ps
-    (fun ps -> ps)
-    (fun t -> ty t)
-    (fun (name, susp, func) -> (name ^ "^-1", susp, func))
-    c
-
-let rec compute_inverse t =
-  match t with
-  | Var x -> raise (NotInvertible (Var.to_string x))
-  | Meta_tm _ -> t
-  | Coh (c, sub) -> (
-      try Coh (coh c, sub)
-      with CohNonInv ->
-        let ps, _, _ = Coh.forget c in
-        let d = Unchecked.dim_ps ps in
-        let pctx = Unchecked.ps_to_ctx ps in
-        let sub = Unchecked.sub_ps_to_sub sub in
-        let sub_inv = sub_inv sub pctx d in
-        let equiv = Opposite.equiv_op_ps ps [ d ] in
-        let coh = Opposite.coh c [ d ] in
-        Coh (coh, Unchecked.sub_ps_apply_sub equiv sub_inv))
-  | App (t, s) ->
-      let t = Tm.develop t in
-      let total_t = Unchecked.tm_apply_sub t s in
-      compute_inverse total_t
-
-and sub_inv s ps i =
-  match (s, ps) with
-  | [], [] -> []
-  | (x, (t, e)) :: sub, (_, (ty, _)) :: ctx when Unchecked.dim_ty ty = i ->
-      (x, (compute_inverse t, e)) :: sub_inv sub ctx i
-  | (x, t) :: sub, _ :: ctx -> (x, t) :: sub_inv sub ctx i
-  | _, _ -> assert false
-
-let compute_inverse t =
-  try compute_inverse t
-  with NotInvertible s ->
-    Error.inversion
-      ("term: " ^ Printing.tm_to_string t)
-      (Printf.sprintf "term %s is not invertible" s)
-
-let group_vertically ps t src_t tgt_t =
-  let coh_unbiased = Coh.check_noninv ps src_t tgt_t ("unbiased_comp", 0, []) in
-  let coh_vertically_grouped = Ps_reduction.coh coh_unbiased in
-  let reduce = Ps_reduction.reduction_sub ps in
-  let t_vertically_grouped = Coh (coh_vertically_grouped, reduce) in
-  Coh.check_inv ps t t_vertically_grouped ("vertical_grouping", 0, [])
-
-type lin_comp = { arity : int; dim : int; sub_ps : sub_ps }
-
-let tm_to_lin_comp t =
-  let ps, sub_ps =
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Opposite = Opposite.Make (Theory)
+  module Ps_reduction = Ps_reduction.Make (Theory)
+  module Telescope = Telescope.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
+
+  exception NotInvertible of string
+  exception CohNonInv
+
+  let ty t =
     match t with
-    | Coh (c, s) ->
-        let ps, _, _ = Coh.forget c in
-        (ps, s)
-    | _ -> Error.fatal "term must be a linear composite"
-  in
-  let dim = Unchecked.dim_ps ps in
-  let rec arity i ps =
-    match (i, ps) with
-    | 0, Br l -> List.length l
-    | _, Br [ Br l ] -> arity (i - 1) (Br l)
-    | _ -> Error.fatal "term must be a linear composite"
-  in
-  { arity = arity (dim - 1) ps; dim; sub_ps }
-
-let rec cancel_linear_comp lc =
-  let k = lc.arity / 2 in
-  let rec sub_to_telescope i sub invs =
-    match (i, sub, invs) with
-    | 0, s, _ -> List.map fst s
-    | i, (t, _) :: _ :: s, invs when i > k ->
-        sub_to_telescope (i - 1) s (t :: invs)
-    | i, (t, _) :: (x, _) :: s, t_inv :: invs ->
-        compute_witness t :: t_inv :: t :: x :: sub_to_telescope (i - 1) s invs
-    | _, _, _ -> Error.fatal "term must be a linear composite"
-  in
-  let tel = Telescope.checked k in
-  let ctel = Telescope.ctx k in
-  let stel =
-    Unchecked.list_to_sub
-      (sub_to_telescope (2 * k) lc.sub_ps [])
-      (Suspension.ctx (Some (lc.dim - 1)) ctel)
-  in
-  App (Suspension.checked_tm (Some (lc.dim - 1)) tel, stel)
-
-and cancel_all_linear_comp t =
-  let c, sub = match t with Coh (c, sub) -> (c, sub) | _ -> Error.fatal "" in
-  let ps, _, _ = Coh.forget c in
-  let d = Unchecked.dim_ps ps in
-  let rec compute_sub i ps sub ty_base =
-    match (ps, sub) with
-    | Br [], [ t ] -> [ t ]
-    | Br [ Br [] ], (t, _) :: (_, _) :: (src_t, _) :: sub when i = d - 1 ->
-        let t_wit = cancel_linear_comp (tm_to_lin_comp t) in
-        let id_src_t =
-          let sub_base = Unchecked.ty_to_sub_ps ty_base in
-          let id =
-            Suspension.coh (Some (Unchecked.dim_ty ty_base)) (Builtin.id ())
+    | Obj | Meta_ty _ -> assert false
+    | Arr (a, u, v) -> Arr (a, v, u)
+
+  let coh c =
+    if not (Coh.is_inv c) then raise CohNonInv;
+    Coh.apply_ps
+      (fun ps -> ps)
+      (fun t -> ty t)
+      (fun (name, susp, func) -> (name ^ "^-1", susp, func))
+      c
+
+  let rec compute_inverse t =
+    match t with
+    | Var x -> raise (NotInvertible (Var.to_string x))
+    | Meta_tm _ -> t
+    | Coh (c, sub) -> (
+        try Coh (coh c, sub)
+        with CohNonInv ->
+          let ps, _, _ = Coh.forget c in
+          let d = Unchecked.dim_ps ps in
+          let pctx = Unchecked.ps_to_ctx ps in
+          let sub = Unchecked.sub_ps_to_sub sub in
+          let sub_inv = sub_inv sub pctx d in
+          let equiv = Opposite.equiv_op_ps ps [ d ] in
+          let coh = Opposite.coh c [ d ] in
+          Coh (coh, Unchecked.sub_ps_apply_sub equiv sub_inv))
+    | App (t, s) ->
+        let t = Tm.develop t in
+        let total_t = Unchecked.tm_apply_sub t s in
+        compute_inverse total_t
+
+  and sub_inv s ps i =
+    match (s, ps) with
+    | [], [] -> []
+    | (x, (t, e)) :: sub, (_, (ty, _)) :: ctx when Unchecked.dim_ty ty = i ->
+        (x, (compute_inverse t, e)) :: sub_inv sub ctx i
+    | (x, t) :: sub, _ :: ctx -> (x, t) :: sub_inv sub ctx i
+    | _, _ -> assert false
+
+  let compute_inverse t =
+    try compute_inverse t
+    with NotInvertible s ->
+      Error.inversion
+        ("term: " ^ Printing.tm_to_string t)
+        (Printf.sprintf "term %s is not invertible" s)
+
+  let group_vertically ps t src_t tgt_t =
+    let coh_unbiased =
+      Coh.check_noninv ps src_t tgt_t ("unbiased_comp", 0, [])
+    in
+    let coh_vertically_grouped = Ps_reduction.coh coh_unbiased in
+    let reduce = Ps_reduction.reduction_sub ps in
+    let t_vertically_grouped = Coh (coh_vertically_grouped, reduce) in
+    Coh.check_inv ps t t_vertically_grouped ("vertical_grouping", 0, [])
+
+  type lin_comp = { arity : int; dim : int; sub_ps : sub_ps }
+
+  let tm_to_lin_comp t =
+    let ps, sub_ps =
+      match t with
+      | Coh (c, s) ->
+          let ps, _, _ = Coh.forget c in
+          (ps, s)
+      | _ -> Error.fatal "term must be a linear composite"
+    in
+    let dim = Unchecked.dim_ps ps in
+    let rec arity i ps =
+      match (i, ps) with
+      | 0, Br l -> List.length l
+      | _, Br [ Br l ] -> arity (i - 1) (Br l)
+      | _ -> Error.fatal "term must be a linear composite"
+    in
+    { arity = arity (dim - 1) ps; dim; sub_ps }
+
+  let rec cancel_linear_comp lc =
+    let k = lc.arity / 2 in
+    let rec sub_to_telescope i sub invs =
+      match (i, sub, invs) with
+      | 0, s, _ -> List.map fst s
+      | i, (t, _) :: _ :: s, invs when i > k ->
+          sub_to_telescope (i - 1) s (t :: invs)
+      | i, (t, _) :: (x, _) :: s, t_inv :: invs ->
+          compute_witness t :: t_inv :: t :: x
+          :: sub_to_telescope (i - 1) s invs
+      | _, _, _ -> Error.fatal "term must be a linear composite"
+    in
+    let tel = Telescope.checked k in
+    let ctel = Telescope.ctx k in
+    let stel =
+      Unchecked.list_to_sub
+        (sub_to_telescope (2 * k) lc.sub_ps [])
+        (Suspension.ctx (Some (lc.dim - 1)) ctel)
+    in
+    App (Suspension.checked_tm (Some (lc.dim - 1)) tel, stel)
+
+  and cancel_all_linear_comp t =
+    let c, sub =
+      match t with Coh (c, sub) -> (c, sub) | _ -> Error.fatal ""
+    in
+    let ps, _, _ = Coh.forget c in
+    let d = Unchecked.dim_ps ps in
+    let rec compute_sub i ps sub ty_base =
+      match (ps, sub) with
+      | Br [], [ t ] -> [ t ]
+      | Br [ Br [] ], (t, _) :: (_, _) :: (src_t, _) :: sub when i = d - 1 ->
+          let t_wit = cancel_linear_comp (tm_to_lin_comp t) in
+          let id_src_t =
+            let sub_base = Unchecked.ty_to_sub_ps ty_base in
+            let id =
+              Suspension.coh (Some (Unchecked.dim_ty ty_base)) (Builtin.id ())
+            in
+            Coh (id, (src_t, true) :: sub_base)
           in
-          Coh (id, (src_t, true) :: sub_base)
-        in
-        (t_wit, true) :: (id_src_t, false) :: (t, false) :: (src_t, false)
-        :: (src_t, false) :: sub
-    | Br l, sub ->
-        let incls = Unchecked.canonical_inclusions l in
-        let sub = Unchecked.sub_ps_to_sub sub in
-        let lsubs =
-          List.map2
-            (fun p incl ->
-              let s =
-                Unchecked.(sub_ps_to_sub_ps_bp (sub_ps_apply_sub incl sub))
-              in
-              {
-                Unchecked.sub_ps =
-                  compute_sub (i + 1) p s.sub_ps (Arr (ty_base, s.l, s.r));
-                l = s.l;
-                r = s.r;
-              })
-            l incls
+          (t_wit, true) :: (id_src_t, false) :: (t, false) :: (src_t, false)
+          :: (src_t, false) :: sub
+      | Br l, sub ->
+          let incls = Unchecked.canonical_inclusions l in
+          let sub = Unchecked.sub_ps_to_sub sub in
+          let lsubs =
+            List.map2
+              (fun p incl ->
+                let s =
+                  Unchecked.(sub_ps_to_sub_ps_bp (sub_ps_apply_sub incl sub))
+                in
+                {
+                  Unchecked.sub_ps =
+                    compute_sub (i + 1) p s.sub_ps (Arr (ty_base, s.l, s.r));
+                  l = s.l;
+                  r = s.r;
+                })
+              l incls
+          in
+          Unchecked.wedge_sub_ps_bp lsubs
+    in
+    Coh (Functorialisation.coh_all_depth0 c, compute_sub 0 ps sub Obj)
+
+  and compute_witness t =
+    match t with
+    | Var x -> raise (NotInvertible (Var.to_string x))
+    | Meta_tm _ ->
+        raise (NotInvertible "Meta_variable not allowed in witness generation")
+    | Coh (c, s) ->
+        let ps, ty, pp_data = Coh.forget c in
+        let d = Coh.dim c in
+        let sub_base, u, v =
+          match ty with
+          | Arr (ty, u, v) -> (Unchecked.ty_to_sub_ps ty, u, v)
+          | _ -> Error.fatal "invertible coherence has to be an arrow type"
         in
-        Unchecked.wedge_sub_ps_bp lsubs
-  in
-  Coh (Functorialisation.coh_all_depth0 c, compute_sub 0 ps sub Obj)
-
-and compute_witness t =
-  match t with
-  | Var x -> raise (NotInvertible (Var.to_string x))
-  | Meta_tm _ ->
-      raise (NotInvertible "Meta_variable not allowed in witness generation")
-  | Coh (c, s) ->
-      let ps, ty, pp_data = Coh.forget c in
-      let d = Coh.dim c in
-      let sub_base, u, v =
-        match ty with
-        | Arr (ty, u, v) -> (Unchecked.ty_to_sub_ps ty, u, v)
-        | _ -> Error.fatal "invertible coherence has to be an arrow type"
+        if Coh.is_inv c then
+          compute_witness_coh_inv c s ~ps ~d ~pp_data ~sub_base ~u ~v
+        else compute_witness_comp c s ~ps ~d ~sub_base ~u ~v
+    | App (t, s) ->
+        let t = Tm.develop t in
+        let total_t = Unchecked.tm_apply_sub t s in
+        compute_witness total_t
+
+  and compute_witness_coh_inv c s ~ps ~pp_data ~d ~sub_base ~u ~v =
+    let name, susp, func = pp_data in
+    let src_wit =
+      let id_ps = Unchecked.identity_ps ps in
+      let c_inv = coh c in
+      let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
+      let c_c_inv =
+        (Coh (c_inv, id_ps), true)
+        :: (u, false)
+        :: (Coh (c, id_ps), true)
+        :: (v, true) :: (u, true) :: sub_base
       in
-      if Coh.is_inv c then
-        compute_witness_coh_inv c s ~ps ~d ~pp_data ~sub_base ~u ~v
-      else compute_witness_comp c s ~ps ~d ~sub_base ~u ~v
-  | App (t, s) ->
-      let t = Tm.develop t in
-      let total_t = Unchecked.tm_apply_sub t s in
-      compute_witness total_t
-
-and compute_witness_coh_inv c s ~ps ~pp_data ~d ~sub_base ~u ~v =
-  let name, susp, func = pp_data in
-  let src_wit =
-    let id_ps = Unchecked.identity_ps ps in
-    let c_inv = coh c in
-    let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
-    let c_c_inv =
-      (Coh (c_inv, id_ps), true)
-      :: (u, false)
-      :: (Coh (c, id_ps), true)
-      :: (v, true) :: (u, true) :: sub_base
+      Coh (comp, c_c_inv)
     in
-    Coh (comp, c_c_inv)
-  in
-  let tgt_wit =
-    let id = Suspension.coh (Some (d - 1)) (Builtin.id ()) in
-    let sub_id_u = (u, true) :: sub_base in
-    Coh (id, sub_id_u)
-  in
-  let c_wit = Coh.check_inv ps src_wit tgt_wit (name ^ "_Unit", susp, func) in
-  Coh (c_wit, s)
-
-and compute_witness_comp c s ~ps ~d ~sub_base ~u ~v =
-  let ps_doubled, inl, inr = Unchecked.ps_compose (d - 1) ps ps in
-  let t =
-    let tm1 = Coh (c, inl) in
-    let c_op = Opposite.coh c [ d ] in
-    let tm2 = Coh (c_op, inr) in
-    let sub_inr = Unchecked.sub_ps_to_sub inr in
-    let sub_inl = Unchecked.sub_ps_to_sub inl in
-    let w = Unchecked.tm_apply_sub (Coh.tgt c_op) sub_inr in
-    let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
-    Coh
-      ( comp,
-        (tm2, true) :: (w, false) :: (tm1, true)
-        :: Unchecked.sub_ps_apply_sub
-             ((v, false) :: (u, false) :: sub_base)
-             sub_inl )
-  in
-  let ps_reduced =
-    Ps_reduction.reduce (Unchecked.dim_ps ps_doubled - 1) ps_doubled
-  in
-  let src_c, _, _ = Coh.noninv_srctgt c in
-  let cps = Unchecked.ps_to_ctx ps in
-  let sub = Unchecked.sub_ps_to_sub s in
-  let m1, src_m1, tgt_m1 =
-    let coh = group_vertically ps_doubled t src_c src_c in
-    let src, tgt = (Coh.src coh, Coh.tgt coh) in
-    let sinv =
-      Unchecked.sub_ps_apply_sub
-        (Opposite.equiv_op_ps ps [ d ])
-        (sub_inv sub cps d)
+    let tgt_wit =
+      let id = Suspension.coh (Some (d - 1)) (Builtin.id ()) in
+      let sub_id_u = (u, true) :: sub_base in
+      Coh (id, sub_id_u)
     in
-    let ssinv = Unchecked.pullback_up (d - 1) ps ps s sinv in
-    let subsinv = Unchecked.sub_ps_to_sub ssinv in
-    ( Coh (coh, ssinv),
-      Unchecked.tm_apply_sub src subsinv,
-      Unchecked.tm_apply_sub tgt subsinv )
-  in
-  let m2 = cancel_all_linear_comp tgt_m1 in
-  let m3, src_m3, tgt_m3 =
-    let coh = Builtin.unbiased_unitor ps_reduced src_c in
-    let src, tgt = (Coh.src coh, Coh.tgt coh) in
-    let s = Unchecked.sub_ps_apply_sub (Unchecked.ps_src ps) sub in
+    let c_wit = Coh.check_inv ps src_wit tgt_wit (name ^ "_Unit", susp, func) in
+    Coh (c_wit, s)
+
+  and compute_witness_comp c s ~ps ~d ~sub_base ~u ~v =
+    let ps_doubled, inl, inr = Unchecked.ps_compose (d - 1) ps ps in
+    let t =
+      let tm1 = Coh (c, inl) in
+      let c_op = Opposite.coh c [ d ] in
+      let tm2 = Coh (c_op, inr) in
+      let sub_inr = Unchecked.sub_ps_to_sub inr in
+      let sub_inl = Unchecked.sub_ps_to_sub inl in
+      let w = Unchecked.tm_apply_sub (Coh.tgt c_op) sub_inr in
+      let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
+      Coh
+        ( comp,
+          (tm2, true) :: (w, false) :: (tm1, true)
+          :: Unchecked.sub_ps_apply_sub
+               ((v, false) :: (u, false) :: sub_base)
+               sub_inl )
+    in
+    let ps_reduced =
+      Ps_reduction.reduce (Unchecked.dim_ps ps_doubled - 1) ps_doubled
+    in
+    let src_c, _, _ = Coh.noninv_srctgt c in
+    let cps = Unchecked.ps_to_ctx ps in
     let sub = Unchecked.sub_ps_to_sub s in
-    ( Coh (coh, s),
-      Unchecked.tm_apply_sub src sub,
-      Unchecked.tm_apply_sub tgt sub )
-  in
-  let sub_total =
-    (m3, true) :: (tgt_m3, false) :: (m2, true) :: (src_m3, false) :: (m1, true)
-    :: (tgt_m1, false) :: (src_m1, false)
-    :: Unchecked.sub_ps_apply_sub ((u, false) :: (u, false) :: sub_base) sub
-  in
-  Coh (Suspension.coh (Some d) (Builtin.comp_n 3), sub_total)
-
-let compute_witness t =
-  try
-    let r = compute_witness t in
-    Io.info ~v:3
-      (lazy (Printf.sprintf "inverse term: %s" (Printing.tm_to_string r)));
-    r
-  with NotInvertible s ->
-    Error.inversion
-      ("term: " ^ Printing.tm_to_string t)
-      (Printf.sprintf "term %s is not invertible" s)
-
-let inverse t =
-  fst
-    (Tm.apply
-       (fun x -> x)
-       compute_inverse
-       (fun (n, s, f) -> (Printf.sprintf "I(%s)" n, s, f))
-       t)
+    let m1, src_m1, tgt_m1 =
+      let coh = group_vertically ps_doubled t src_c src_c in
+      let src, tgt = (Coh.src coh, Coh.tgt coh) in
+      let sinv =
+        Unchecked.sub_ps_apply_sub
+          (Opposite.equiv_op_ps ps [ d ])
+          (sub_inv sub cps d)
+      in
+      let ssinv = Unchecked.pullback_up (d - 1) ps ps s sinv in
+      let subsinv = Unchecked.sub_ps_to_sub ssinv in
+      ( Coh (coh, ssinv),
+        Unchecked.tm_apply_sub src subsinv,
+        Unchecked.tm_apply_sub tgt subsinv )
+    in
+    let m2 = cancel_all_linear_comp tgt_m1 in
+    let m3, src_m3, tgt_m3 =
+      let coh = Builtin.unbiased_unitor ps_reduced src_c in
+      let src, tgt = (Coh.src coh, Coh.tgt coh) in
+      let s = Unchecked.sub_ps_apply_sub (Unchecked.ps_src ps) sub in
+      let sub = Unchecked.sub_ps_to_sub s in
+      ( Coh (coh, s),
+        Unchecked.tm_apply_sub src sub,
+        Unchecked.tm_apply_sub tgt sub )
+    in
+    let sub_total =
+      (m3, true) :: (tgt_m3, false) :: (m2, true) :: (src_m3, false)
+      :: (m1, true) :: (tgt_m1, false) :: (src_m1, false)
+      :: Unchecked.sub_ps_apply_sub ((u, false) :: (u, false) :: sub_base) sub
+    in
+    Coh (Suspension.coh (Some d) (Builtin.comp_n 3), sub_total)
+
+  let compute_witness t =
+    try
+      let r = compute_witness t in
+      Io.info ~v:3
+        (lazy (Printf.sprintf "inverse term: %s" (Printing.tm_to_string r)));
+      r
+    with NotInvertible s ->
+      Error.inversion
+        ("term: " ^ Printing.tm_to_string t)
+        (Printf.sprintf "term %s is not invertible" s)
+
+  let inverse t =
+    fst
+      (Tm.apply
+         (fun x -> x)
+         compute_inverse
+         (fun (n, s, f) -> (Printf.sprintf "I(%s)" n, s, f))
+         t)
+end
diff --git a/lib/meta_operations/inverse.mli b/lib/meta_operations/inverse.mli
index 3ab5c4a9..221f29c6 100644
--- a/lib/meta_operations/inverse.mli
+++ b/lib/meta_operations/inverse.mli
@@ -1,6 +1,8 @@
-open Kernel
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val ty : ty -> ty
-val compute_inverse : tm -> tm
-val compute_witness : tm -> tm
-val inverse : Tm.t -> Tm.t
+  val ty : ty -> ty
+  val compute_inverse : tm -> tm
+  val compute_witness : tm -> tm
+  val inverse : Tm.t -> Tm.t
+end
diff --git a/lib/meta_operations/opposite.ml b/lib/meta_operations/opposite.ml
index b2e31c2a..e9c6cd0c 100644
--- a/lib/meta_operations/opposite.ml
+++ b/lib/meta_operations/opposite.ml
@@ -1,109 +1,113 @@
 open Common
-open Kernel
 
 let rec op_data_to_string = function
   | [] -> ""
   | [ i ] -> Printf.sprintf "%i" i
   | i :: l -> Printf.sprintf "%i,%s" i (op_data_to_string l)
 
-let ps ps op_data =
-  let rec level i ps =
-    match ps with
-    | Br [] -> Br []
-    | Br l when List.mem (i + 1) op_data ->
-        let l = List.map (level (i + 1)) l in
-        Br (List.rev l)
-    | Br l -> Br (List.map (level (i + 1)) l)
-  in
-  level 0 ps
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
 
-let equiv_op_ps ps op_data =
-  let rec level i ps =
-    match ps with
-    | Br [] -> [ (Var (Var.Db 0), true) ]
-    | Br l ->
-        let components = List.map (fun p -> level (i + 1) p) l in
-        if List.mem (i + 1) op_data then
-          Unchecked.opsuspwedge_subs_ps components l
-        else Unchecked.suspwedge_subs_ps components l
-  in
-  level 0 ps
+  let ps ps op_data =
+    let rec level i ps =
+      match ps with
+      | Br [] -> Br []
+      | Br l when List.mem (i + 1) op_data ->
+          let l = List.map (level (i + 1)) l in
+          Br (List.rev l)
+      | Br l -> Br (List.map (level (i + 1)) l)
+    in
+    level 0 ps
 
-let op_pp_data pp_data op_data =
-  let name = Printing.full_name pp_data in
-  let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
-  (name, 0, [])
+  let equiv_op_ps ps op_data =
+    let rec level i ps =
+      match ps with
+      | Br [] -> [ (Var (Var.Db 0), true) ]
+      | Br l ->
+          let components = List.map (fun p -> level (i + 1) p) l in
+          if List.mem (i + 1) op_data then
+            Unchecked.opsuspwedge_subs_ps components l
+          else Unchecked.suspwedge_subs_ps components l
+    in
+    level 0 ps
 
-let rec ty typ op_data =
-  let d = Unchecked.dim_ty typ in
-  match typ with
-  | Obj -> Obj
-  | Arr (a, t, u) ->
-      let a = ty a op_data in
-      let t = tm t op_data in
-      let u = tm u op_data in
-      if List.mem d op_data then Arr (a, u, t) else Arr (a, t, u)
-  | Meta_ty m -> Meta_ty m
+  let op_pp_data pp_data op_data =
+    let name = Printing.full_name pp_data in
+    let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
+    (name, 0, [])
 
-and tm t op_data =
-  match t with
-  | Var x -> Var x
-  | Coh (c, s) ->
-      let p, _, _ = Coh.forget c in
-      let equiv = equiv_op_ps p op_data in
-      let c = coh c op_data equiv in
-      let op_s = sub (Unchecked.sub_ps_to_sub s) op_data in
-      let s' = Unchecked.sub_ps_apply_sub equiv op_s in
-      Coh (c, s')
-  | App (t, s) ->
-      let op_t, _ =
-        Tm.apply
-          (fun c -> ctx c op_data)
-          (fun t -> tm t op_data)
-          (fun pp_data -> op_pp_data pp_data op_data)
-          t
-      in
-      let op_s = sub s op_data in
-      let op_s = Unchecked.(sub_ps_to_sub (sub_to_sub_ps op_s)) in
-      App (op_t, op_s)
-  | Meta_tm m -> Meta_tm m
+  let rec ty typ op_data =
+    let d = Unchecked.dim_ty typ in
+    match typ with
+    | Obj -> Obj
+    | Arr (a, t, u) ->
+        let a = ty a op_data in
+        let t = tm t op_data in
+        let u = tm u op_data in
+        if List.mem d op_data then Arr (a, u, t) else Arr (a, t, u)
+    | Meta_ty m -> Meta_ty m
 
-and sub s op_data =
-  match s with
-  | [] -> []
-  | (x, (t, e)) :: s -> (x, (tm t op_data, e)) :: sub s op_data
+  and tm t op_data =
+    match t with
+    | Var x -> Var x
+    | Coh (c, s) ->
+        let p, _, _ = Coh.forget c in
+        let equiv = equiv_op_ps p op_data in
+        let c = coh c op_data equiv in
+        let op_s = sub (Unchecked.sub_ps_to_sub s) op_data in
+        let s' = Unchecked.sub_ps_apply_sub equiv op_s in
+        Coh (c, s')
+    | App (t, s) ->
+        let op_t, _ =
+          Tm.apply
+            (fun c -> ctx c op_data)
+            (fun t -> tm t op_data)
+            (fun pp_data -> op_pp_data pp_data op_data)
+            t
+        in
+        let op_s = sub s op_data in
+        let op_s = Unchecked.(sub_ps_to_sub (sub_to_sub_ps op_s)) in
+        App (op_t, op_s)
+    | Meta_tm m -> Meta_tm m
 
-and coh c op_data equiv =
-  Coh.apply_ps
-    (fun p -> ps p op_data)
-    (fun t ->
-      Unchecked.ty_sub_preimage (ty t op_data) (Unchecked.sub_ps_to_sub equiv))
-    (fun pp -> op_pp_data pp op_data)
-    c
+  and sub s op_data =
+    match s with
+    | [] -> []
+    | (x, (t, e)) :: s -> (x, (tm t op_data, e)) :: sub s op_data
 
-and ctx c op_data =
-  match c with
-  | [] -> []
-  | (x, (t, e)) :: c ->
-      let t = ty t op_data in
-      let c = ctx c op_data in
-      (x, (t, e)) :: c
+  and coh c op_data equiv =
+    Coh.apply_ps
+      (fun p -> ps p op_data)
+      (fun t ->
+        Unchecked.ty_sub_preimage (ty t op_data) (Unchecked.sub_ps_to_sub equiv))
+      (fun pp -> op_pp_data pp op_data)
+      c
 
-let coh c op_data =
-  let ps, _, _ = Coh.forget c in
-  let equiv = equiv_op_ps ps op_data in
-  coh c op_data equiv
+  and ctx c op_data =
+    match c with
+    | [] -> []
+    | (x, (t, e)) :: c ->
+        let t = ty t op_data in
+        let c = ctx c op_data in
+        (x, (t, e)) :: c
 
-let tm t op_data =
-  Io.info ~v:3 (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
-  let t = tm t op_data in
-  Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
-  t
+  let coh c op_data =
+    let ps, _, _ = Coh.forget c in
+    let equiv = equiv_op_ps ps op_data in
+    coh c op_data equiv
 
-let checked_tm t op_data =
-  let name = Option.map (fun a -> op_pp_data a op_data) (Tm.pp_data t) in
-  let c = Tm.ctx t in
-  let t = Tm.develop t in
-  let c = ctx c op_data in
-  let t = tm t op_data in
-  check_term (Ctx.check c) ?name t
+  let tm t op_data =
+    Io.info ~v:3
+      (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
+    let t = tm t op_data in
+    Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
+    t
+
+  let checked_tm t op_data =
+    let name = Option.map (fun a -> op_pp_data a op_data) (Tm.pp_data t) in
+    let c = Tm.ctx t in
+    let t = Tm.develop t in
+    let c = ctx c op_data in
+    let t = tm t op_data in
+    check_term (Ctx.check c) ?name t
+end
diff --git a/lib/meta_operations/opposite.mli b/lib/meta_operations/opposite.mli
index 816532b6..b80053c4 100644
--- a/lib/meta_operations/opposite.mli
+++ b/lib/meta_operations/opposite.mli
@@ -1,11 +1,15 @@
 open Common
-open Kernel
 
 val op_data_to_string : op_data -> string
-val equiv_op_ps : ps -> op_data -> sub_ps
-val tm : tm -> op_data -> tm
-val coh : Coh.t -> op_data -> Coh.t
-val sub : sub -> op_data -> sub
-val ty : ty -> op_data -> ty
-val ctx : ctx -> op_data -> ctx
-val checked_tm : Tm.t -> op_data -> Tm.t
+
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
+
+  val equiv_op_ps : ps -> op_data -> sub_ps
+  val tm : tm -> op_data -> tm
+  val coh : Coh.t -> op_data -> Coh.t
+  val sub : sub -> op_data -> sub
+  val ty : ty -> op_data -> ty
+  val ctx : ctx -> op_data -> ctx
+  val checked_tm : Tm.t -> op_data -> Tm.t
+end
diff --git a/lib/meta_operations/padding.ml b/lib/meta_operations/padding.ml
index 635d94e9..44ce628d 100644
--- a/lib/meta_operations/padding.ml
+++ b/lib/meta_operations/padding.ml
@@ -1,520 +1,528 @@
 open Common
-open Kernel
 
-module type StringS = sig
-  val value : string
-end
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Construct = Construct.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
 
-module Filtration = struct
-  (* Data defining a filtration *)
-  module type MakerS = sig
-    val min : int
-    val max : int
-    val ctx : int -> ctx
-    val v : int -> Var.t
+  module type StringS = sig
+    val value : string
   end
 
-  (* Functions relative to a filtration *)
-  module type S = sig
-    include MakerS
+  module Filtration = struct
+    (* Data defining a filtration *)
+    module type MakerS = sig
+      val min : int
+      val max : int
+      val ctx : int -> ctx
+      val v : int -> Var.t
+    end
 
-    val sub : int -> sub
-    val v_constr : int -> constr
-    val src_v : int -> constr
-    val tgt_v : int -> constr
-    val v_plus : int -> Var.t
-    val v_bridge : int -> Var.t
-    val in_plus : int -> sub
-    val in_minus : int -> sub
-  end
+    (* Functions relative to a filtration *)
+    module type S = sig
+      include MakerS
+
+      val sub : int -> sub
+      val v_constr : int -> constr
+      val src_v : int -> constr
+      val tgt_v : int -> constr
+      val v_plus : int -> Var.t
+      val v_bridge : int -> Var.t
+      val in_plus : int -> sub
+      val in_minus : int -> sub
+    end
 
-  module Make (F : MakerS) : S = struct
-    include F
+    module Make (F : MakerS) : S = struct
+      include F
 
-    let v_constr i = (Var (F.v i), fst (List.assoc (F.v i) (F.ctx i)))
-    let src_v i = Construct.src 1 (v_constr i)
-    let tgt_v i = Construct.tgt 1 (v_constr i)
+      let v_constr i = (Var (F.v i), fst (List.assoc (F.v i) (F.ctx i)))
+      let src_v i = Construct.src 1 (v_constr i)
+      let tgt_v i = Construct.tgt 1 (v_constr i)
 
-    let to_db i =
-      let c = Functorialisation.ctx (F.ctx i) [ F.v i ] in
-      Unchecked.db_level_sub_inv c
+      let to_db i =
+        let c = Functorialisation.ctx (F.ctx i) [ F.v i ] in
+        Unchecked.db_level_sub_inv c
 
-    let v_plus i = Display_maps.var_apply_sub (Var.Plus (F.v i)) (to_db i)
-    let v_bridge i = Display_maps.var_apply_sub (Var.Bridge (F.v i)) (to_db i)
+      let v_plus i = Display_maps.var_apply_sub (Var.Plus (F.v i)) (to_db i)
+      let v_bridge i = Display_maps.var_apply_sub (Var.Bridge (F.v i)) (to_db i)
 
-    let in_plus i =
-      let rec aux ctx =
-        match ctx with
-        | [] -> []
-        | (x, (_, _)) :: ctx when x == F.v i ->
-            (v i, (Var (v_plus i), false)) :: aux ctx
-        | (x, (_, b)) :: ctx ->
-            (x, (Unchecked.tm_apply_sub (Var x) (to_db i), b)) :: aux ctx
-      in
-      aux (F.ctx i)
-
-    let in_minus i =
-      let rec aux ctx =
-        match ctx with
-        | [] -> []
-        | (x, (_, _)) :: ctx when x == F.v i ->
-            (v i, (Var (v i), false)) :: aux ctx
-        | (x, (_, b)) :: ctx ->
-            (x, (Unchecked.tm_apply_sub (Var x) (to_db i), b)) :: aux ctx
-      in
-      aux (F.ctx i)
-
-    let sub i =
-      let w = v_constr (i + 1) in
-      let rec aux ctx =
-        match ctx with
-        | [] -> []
-        | (x, (_, _)) :: ctx when x = v i ->
-            (v_bridge i, (Construct.to_tm w, true))
-            :: (v_plus i, (Construct.(to_tm (tgt 1 w)), false))
-            :: (v i, (Construct.(to_tm (src 1 w)), false))
-            :: aux ctx
-        | (x, (_, b)) :: ctx -> (x, (Var x, b)) :: aux ctx
-      in
-      aux (ctx i)
+      let in_plus i =
+        let rec aux ctx =
+          match ctx with
+          | [] -> []
+          | (x, (_, _)) :: ctx when x == F.v i ->
+              (v i, (Var (v_plus i), false)) :: aux ctx
+          | (x, (_, b)) :: ctx ->
+              (x, (Unchecked.tm_apply_sub (Var x) (to_db i), b)) :: aux ctx
+        in
+        aux (F.ctx i)
+
+      let in_minus i =
+        let rec aux ctx =
+          match ctx with
+          | [] -> []
+          | (x, (_, _)) :: ctx when x == F.v i ->
+              (v i, (Var (v i), false)) :: aux ctx
+          | (x, (_, b)) :: ctx ->
+              (x, (Unchecked.tm_apply_sub (Var x) (to_db i), b)) :: aux ctx
+        in
+        aux (F.ctx i)
+
+      let sub i =
+        let w = v_constr (i + 1) in
+        let rec aux ctx =
+          match ctx with
+          | [] -> []
+          | (x, (_, _)) :: ctx when x = v i ->
+              (v_bridge i, (Construct.to_tm w, true))
+              :: (v_plus i, (Construct.(to_tm (tgt 1 w)), false))
+              :: (v i, (Construct.(to_tm (src 1 w)), false))
+              :: aux ctx
+          | (x, (_, b)) :: ctx -> (x, (Var x, b)) :: aux ctx
+        in
+        aux (ctx i)
+    end
   end
-end
 
-module Padding = struct
-  let pad_one_step p q previous v sigma =
-    let prev =
-      Construct.tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sigma
-    in
-    Construct.comp3 (Tm.constr p) prev (Tm.constr q)
+  module Padding = struct
+    let pad_one_step p q previous v sigma =
+      let prev =
+        Construct.tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sigma
+      in
+      Construct.comp3 (Tm.constr p) prev (Tm.constr q)
 
-  module type PaddingDataS = sig
-    val p : int -> Tm.t
-    val q : int -> Tm.t
-  end
+    module type PaddingDataS = sig
+      val p : int -> Tm.t
+      val q : int -> Tm.t
+    end
 
-  module type PaddedS = sig
-    val padded : int -> Tm.t
-  end
+    module type PaddedS = sig
+      val padded : int -> Tm.t
+    end
 
-  module Padded (F : Filtration.S) (D : PaddingDataS) (Name : StringS) :
-    PaddedS = struct
-    let memo_padded : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
-
-    let rec padded i =
-      let compute_padded i =
-        let name = (Printf.sprintf "%s.Padding(%d)" Name.value i, 0, []) in
-        let padded_constr =
-          if i = F.min then F.v_constr i
-          else
-            pad_one_step
-              (D.p (i - 1))
-              (D.q (i - 1))
-              (padded (i - 1))
-              (F.v (i - 1))
-              (F.sub (i - 1))
+    module Padded (F : Filtration.S) (D : PaddingDataS) (Name : StringS) :
+      PaddedS = struct
+      let memo_padded : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+
+      let rec padded i =
+        let compute_padded i =
+          let name = (Printf.sprintf "%s.Padding(%d)" Name.value i, 0, []) in
+          let padded_constr =
+            if i = F.min then F.v_constr i
+            else
+              pad_one_step
+                (D.p (i - 1))
+                (D.q (i - 1))
+                (padded (i - 1))
+                (F.v (i - 1))
+                (F.sub (i - 1))
+          in
+          check_constr (F.ctx i) ~name padded_constr
         in
-        check_constr (F.ctx i) ~name padded_constr
-      in
-      match Hashtbl.find_opt memo_padded i with
-      | Some padded -> padded
-      | None ->
-          let padded = compute_padded i in
-          Hashtbl.add memo_padded i padded;
-          padded
-  end
+        match Hashtbl.find_opt memo_padded i with
+        | Some padded -> padded
+        | None ->
+            let padded = compute_padded i in
+            Hashtbl.add memo_padded i padded;
+            padded
+    end
 
-  (* Several padding data we consider are canonical -- they are given by a single
+    (* Several padding data we consider are canonical -- they are given by a single
      coherence in a well-chosen pasting scheme. The following aims at streamlining
      the construction of such padding data *)
-  module type CanonicalPaddingDataArgsS = sig
-    val ps : int -> ps
-    val p_src : int -> constr
-    val q_tgt : int -> constr
-    val p_inc : int -> constr list
-    val q_inc : int -> constr list
-    val pad_in_ps : int -> sub
-  end
-
-  module CanonicalPaddingData
-      (F : Filtration.S)
-      (Args : CanonicalPaddingDataArgsS)
-      (P : PaddedS)
-      (Name : StringS) =
-  struct
-    let p i =
-      let padded_subbed =
-        Construct.tm_app_sub (P.padded i) (Args.pad_in_ps i)
-      in
-      let ty = Construct.arr (Args.p_src i) padded_subbed in
-      let name = (Printf.sprintf "%s.p(%d)" Name.value i, 0, []) in
-      let coh = check_coh (Args.ps i) ty name in
-      check_constr (F.ctx (i + 1)) (Construct.coh_app coh (Args.p_inc i))
-
-    let q i =
-      let padded_subbed =
-        Construct.tm_app_sub (P.padded i) (Args.pad_in_ps i)
-      in
-      let ty = Construct.arr padded_subbed (Args.q_tgt i) in
-      let name = (Printf.sprintf "%s.p(%d)" Name.value i, 0, []) in
-      let coh = check_coh (Args.ps i) ty name in
-      check_constr (F.ctx (i + 1)) (Construct.coh_app coh (Args.q_inc i))
-  end
-
-  module type MakerS = sig
-    module F : Filtration.S
-    module D : PaddingDataS
-    module P : PaddedS
-
-    val name : string
-  end
-
-  module type S = sig
-    include MakerS
-
-    val ctx : ctx
-    val v : Var.t
-    val v_constr : constr
-    val v_plus : Var.t
-    val v_bridge : Var.t
-    val p : Tm.t
-    val q : Tm.t
-    val padded : Tm.t
-    val padded_func : int -> int -> Tm.t
-  end
-
-  module Make (A : MakerS) : S = struct
-    module F = A.F
-
-    module D = struct
-      include A.D
-
-      let memo_p : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
-      let memo_q : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+    module type CanonicalPaddingDataArgsS = sig
+      val ps : int -> ps
+      val p_src : int -> constr
+      val q_tgt : int -> constr
+      val p_inc : int -> constr list
+      val q_inc : int -> constr list
+      val pad_in_ps : int -> sub
+    end
 
+    module CanonicalPaddingData
+        (F : Filtration.S)
+        (Args : CanonicalPaddingDataArgsS)
+        (P : PaddedS)
+        (Name : StringS) =
+    struct
       let p i =
-        match Hashtbl.find_opt memo_p i with
-        | Some padded -> padded
-        | None ->
-            let padded = p i in
-            Hashtbl.add memo_p i padded;
-            padded
+        let padded_subbed =
+          Construct.tm_app_sub (P.padded i) (Args.pad_in_ps i)
+        in
+        let ty = Construct.arr (Args.p_src i) padded_subbed in
+        let name = (Printf.sprintf "%s.p(%d)" Name.value i, 0, []) in
+        let coh = check_coh (Args.ps i) ty name in
+        check_constr (F.ctx (i + 1)) (Construct.coh_app coh (Args.p_inc i))
 
       let q i =
-        match Hashtbl.find_opt memo_q i with
-        | Some padded -> padded
-        | None ->
-            let padded = q i in
-            Hashtbl.add memo_q i padded;
-            padded
+        let padded_subbed =
+          Construct.tm_app_sub (P.padded i) (Args.pad_in_ps i)
+        in
+        let ty = Construct.arr padded_subbed (Args.q_tgt i) in
+        let name = (Printf.sprintf "%s.p(%d)" Name.value i, 0, []) in
+        let coh = check_coh (Args.ps i) ty name in
+        check_constr (F.ctx (i + 1)) (Construct.coh_app coh (Args.q_inc i))
     end
 
-    module P = A.P
-
-    let name = A.name
-    let ctx = F.ctx F.max
-    let v = F.v F.max
-    let v_constr = F.v_constr F.max
-    let v_plus = F.v_plus F.max
-    let v_bridge = F.v_bridge F.max
-    let p = D.p F.max
-    let q = D.q F.max
-    let padded = P.padded F.max
-
-    (* Assumption: t is in the i-th context of the filtration *)
-    let rec iterated_func t i r =
-      match r with
-      | 0 -> t
-      | r ->
-          check_constr
-            (F.ctx (i + r))
-            (Construct.tm_app_sub
-               (Functorialisation.tm
-                  (iterated_func t i (r - 1))
-                  [ (F.v (i + r), 1) ])
-               (F.sub (i + r - 1)))
-
-    let padded_func i r = iterated_func (P.padded i) i r
-  end
+    module type MakerS = sig
+      module F : Filtration.S
+      module D : PaddingDataS
+      module P : PaddedS
 
-  module type MakerCanonicalS = sig
-    module F : Filtration.S
-    module D : CanonicalPaddingDataArgsS
+      val name : string
+    end
 
-    val name : string
-  end
+    module type S = sig
+      include MakerS
+
+      val ctx : ctx
+      val v : Var.t
+      val v_constr : constr
+      val v_plus : Var.t
+      val v_bridge : Var.t
+      val p : Tm.t
+      val q : Tm.t
+      val padded : Tm.t
+      val padded_func : int -> int -> Tm.t
+    end
 
-  module MakeCanonical (A : MakerCanonicalS) = Make (struct
-    module F = A.F
+    module Make (A : MakerS) : S = struct
+      module F = A.F
+
+      module D = struct
+        include A.D
+
+        let memo_p : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+        let memo_q : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+
+        let p i =
+          match Hashtbl.find_opt memo_p i with
+          | Some padded -> padded
+          | None ->
+              let padded = p i in
+              Hashtbl.add memo_p i padded;
+              padded
+
+        let q i =
+          match Hashtbl.find_opt memo_q i with
+          | Some padded -> padded
+          | None ->
+              let padded = q i in
+              Hashtbl.add memo_q i padded;
+              padded
+      end
+
+      module P = A.P
+
+      let name = A.name
+      let ctx = F.ctx F.max
+      let v = F.v F.max
+      let v_constr = F.v_constr F.max
+      let v_plus = F.v_plus F.max
+      let v_bridge = F.v_bridge F.max
+      let p = D.p F.max
+      let q = D.q F.max
+      let padded = P.padded F.max
+
+      (* Assumption: t is in the i-th context of the filtration *)
+      let rec iterated_func t i r =
+        match r with
+        | 0 -> t
+        | r ->
+            check_constr
+              (F.ctx (i + r))
+              (Construct.tm_app_sub
+                 (Functorialisation.tm
+                    (iterated_func t i (r - 1))
+                    [ (F.v (i + r), 1) ])
+                 (F.sub (i + r - 1)))
+
+      let padded_func i r = iterated_func (P.padded i) i r
+    end
 
-    let name = A.name
+    module type MakerCanonicalS = sig
+      module F : Filtration.S
+      module D : CanonicalPaddingDataArgsS
 
-    module Name : StringS = struct
-      let value = A.name
+      val name : string
     end
 
-    module rec D : PaddingDataS = CanonicalPaddingData (F) (A.D) (P) (Name)
-    and P : PaddedS = Padded (F) (D) (Name)
-  end)
-end
+    module MakeCanonical (A : MakerCanonicalS) = Make (struct
+      module F = A.F
 
-module type FiltrationMorphismS = sig
-  val sub : int -> sub
-  val name : string
-end
+      let name = A.name
 
-module PaddingApp
-    (Tgt : Filtration.S)
-    (M : FiltrationMorphismS)
-    (P : Padding.S) : Padding.S = Padding.Make (struct
-  module F = Tgt
-
-  module D = struct
-    let p i =
-      check_constr
-        (Tgt.ctx (i + 1))
-        (Construct.tm_app_sub (P.D.p i) (M.sub (i + 1)))
-
-    let q i =
-      check_constr
-        (Tgt.ctx (i + 1))
-        (Construct.tm_app_sub (P.D.q i) (M.sub (i + 1)))
-  end
+      module Name : StringS = struct
+        let value = A.name
+      end
 
-  let name = Printf.sprintf "%s[%s]" P.name M.name
-
-  module P = struct
-    let padded i =
-      check_constr (Tgt.ctx i) (Construct.tm_app_sub (P.P.padded i) (M.sub i))
+      module rec D : PaddingDataS = CanonicalPaddingData (F) (A.D) (P) (Name)
+      and P : PaddedS = Padded (F) (D) (Name)
+    end)
   end
-end)
-
-module Suspend (P : Padding.S) : Padding.S = Padding.Make (struct
-  module F = Filtration.Make (struct
-    let min = P.F.min + 1
-    let max = P.F.max + 1
-    let ctx i = Suspension.ctx (Some 1) (P.F.ctx (i - 1))
-    let v i = P.F.v i
-  end)
 
-  module D = struct
-    let p i = Suspension.checked_tm (Some 1) (P.D.p (i - 1))
-    let q i = Suspension.checked_tm (Some 1) (P.D.q (i - 1))
+  module type FiltrationMorphismS = sig
+    val sub : int -> sub
+    val name : string
   end
 
-  let name = Printf.sprintf "Σ%s" P.name
+  module PaddingApp
+      (Tgt : Filtration.S)
+      (M : FiltrationMorphismS)
+      (P : Padding.S) : Padding.S = Padding.Make (struct
+    module F = Tgt
 
-  module P = struct
-    let padded i = Suspension.checked_tm (Some 1) (P.P.padded (i - 1))
-  end
-end)
-
-module Repadding = struct
-  let hexcomp fminus fplus ybridge fbridge gminus gplus gbridge zbridge hminus
-      hplus hbridge =
-    let d = Construct.dim fminus - 1 in
-    let db n = Var.Db n in
-    let hex =
-      Functorialisation.coh (Builtin.comp_n 3) [ db 6; db 4; db 3; db 2; db 1 ]
-    in
-    let hex = Suspension.checked_tm (Some d) hex in
-    let x = Construct.src 1 fminus in
-    let yminus = Construct.tgt 1 fminus in
-    let yplus = Construct.tgt 1 fplus in
-    let zminus = Construct.src 1 hminus in
-    let zplus = Construct.src 1 hplus in
-    let w = Construct.tgt 1 hminus in
-    let rec list_tgt_src ty =
-      match ty with
-      | Obj -> []
-      | Arr (a, u, v) -> (v, a) :: (u, a) :: list_tgt_src a
-      | _ -> assert false
-    in
-    let sub =
-      hbridge :: hplus :: hminus :: w :: gbridge :: gplus :: gminus :: zbridge
-      :: zplus :: zminus :: fbridge :: fplus :: fminus :: ybridge :: yplus
-      :: yminus :: x
-      :: list_tgt_src (snd w)
-    in
-    (* The call to sub_ps_to_sub is a bit of a hack, relying on the fact that all
-       checked terms use deBruijn. Further refactoring to be done in the kernel to
-       enforce this more statically *)
-    Construct.tm_app hex sub
-
-  let repad_one_step p_0 p_1 f q_0 q_1 g previous iota_minus iota_plus v sub =
-    let padding_0, padding_1 = Tm.bdry previous in
-    hexcomp (Tm.constr p_0) (Tm.constr p_1)
-      Construct.(apply_sub (tm_app_sub previous iota_minus) sub)
-      (Tm.constr f)
-      Construct.(tm_app_sub (Functorialisation.tm padding_0 [ (v, 1) ]) sub)
-      Construct.(tm_app_sub (Functorialisation.tm padding_1 [ (v, 1) ]) sub)
-      Construct.(
-        inverse (tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sub))
-      Construct.(apply_sub (tm_app_sub previous iota_plus) sub)
-      (Tm.constr q_0) (Tm.constr q_1) (Tm.constr g)
-
-  module type RepaddingDataS = sig
-    val f : int -> Tm.t
-    val g : int -> Tm.t
-  end
+    module D = struct
+      let p i =
+        check_constr
+          (Tgt.ctx (i + 1))
+          (Construct.tm_app_sub (P.D.p i) (M.sub (i + 1)))
 
-  module type RepaddedS = sig
-    val repad : int -> Tm.t
-  end
+      let q i =
+        check_constr
+          (Tgt.ctx (i + 1))
+          (Construct.tm_app_sub (P.D.q i) (M.sub (i + 1)))
+    end
 
-  module Repadded
-      (P1 : Padding.S)
-      (P2 : Padding.S)
-      (D : RepaddingDataS)
-      (Name : StringS) =
-  struct
-    let memo_repadded = Hashtbl.create 77
-
-    let rec repad i =
-      let compute_repadding i =
-        let repadding_constr =
-          if i = P1.F.min then Construct.id_n 1 (P1.F.v_constr i)
-          else
-            let previous = repad (i - 1) in
-            let sigma = P1.F.sub (i - 1) in
-            let f, g = (D.f (i - 1), D.g (i - 1)) in
-            repad_one_step
-              (P1.D.p (i - 1))
-              (P2.D.p (i - 1))
-              f
-              (P1.D.q (i - 1))
-              (P2.D.q (i - 1))
-              g previous
-              (P1.F.in_minus (i - 1))
-              (P1.F.in_plus (i - 1))
-              (P1.F.v (i - 1))
-              sigma
-        in
-        let name = (Printf.sprintf "%s.Repadding(%d)" Name.value i, 0, []) in
-        check_constr (P1.F.ctx i) ~name repadding_constr
-      in
-      match Hashtbl.find_opt memo_repadded i with
-      | Some t -> t
-      | None ->
-          let repadded = compute_repadding i in
-          Hashtbl.add memo_repadded i repadded;
-          repadded
-  end
+    let name = Printf.sprintf "%s[%s]" P.name M.name
 
-  module type CanonicalRepaddingDataArgsS = sig
-    val ps : int -> ps
-    val incl : int -> constr list
-  end
+    module P = struct
+      let padded i =
+        check_constr (Tgt.ctx i) (Construct.tm_app_sub (P.P.padded i) (M.sub i))
+    end
+  end)
 
-  module CanonicalRepaddingData
-      (Args : CanonicalRepaddingDataArgsS)
-      (P1 : Padding.S)
-      (P2 : Padding.S)
-      (R : RepaddedS)
-      (Name : StringS) : RepaddingDataS = struct
-    let f i =
-      let ty =
-        Construct.(
-          arr
-            (wcomp
-               (Construct.develop (Tm.constr (P1.D.p i)))
-               i
-               (tm_app_sub (R.repad i)
-                  (Unchecked.sub_apply_sub (P1.F.in_minus i) (P1.F.sub i))))
-            (Construct.develop (Tm.constr (P2.D.p i))))
-      in
-      let name = (Printf.sprintf "%s.f(%d)" Name.value i, 0, []) in
-      let coh = check_coh (Args.ps i) ty name in
-      check_constr (P1.F.ctx i) (Construct.coh_app coh (Args.incl i))
+  module Suspend (P : Padding.S) : Padding.S = Padding.Make (struct
+    module F = Filtration.Make (struct
+      let min = P.F.min + 1
+      let max = P.F.max + 1
+      let ctx i = Suspension.ctx (Some 1) (P.F.ctx (i - 1))
+      let v i = P.F.v i
+    end)
 
-    let g i =
-      let ty =
-        Construct.(
-          arr
-            (Construct.develop (Tm.constr (P1.D.q i)))
-            (wcomp
-               (tm_app_sub (R.repad i)
-                  (Unchecked.sub_apply_sub (P1.F.in_plus i) (P1.F.sub i)))
-               i
-               (Construct.develop (Tm.constr (P2.D.q i)))))
-      in
-      let name = (Printf.sprintf "%s.g(%d)" Name.value i, 0, []) in
-      let coh = check_coh (Args.ps i) ty name in
-      check_constr (P1.F.ctx i) (Construct.coh_app coh (Args.incl i))
-  end
+    module D = struct
+      let p i = Suspension.checked_tm (Some 1) (P.D.p (i - 1))
+      let q i = Suspension.checked_tm (Some 1) (P.D.q (i - 1))
+    end
 
-  module type MakerS = sig
-    module P1 : Padding.S
-    module P2 : Padding.S
-    module D : RepaddingDataS
-    module R : RepaddedS
+    let name = Printf.sprintf "Σ%s" P.name
 
-    val name : string
-  end
+    module P = struct
+      let padded i = Suspension.checked_tm (Some 1) (P.P.padded (i - 1))
+    end
+  end)
 
-  module type S = sig
-    include MakerS
+  module Repadding = struct
+    let hexcomp fminus fplus ybridge fbridge gminus gplus gbridge zbridge hminus
+        hplus hbridge =
+      let d = Construct.dim fminus - 1 in
+      let db n = Var.Db n in
+      let hex =
+        Functorialisation.coh (Builtin.comp_n 3)
+          [ db 6; db 4; db 3; db 2; db 1 ]
+      in
+      let hex = Suspension.checked_tm (Some d) hex in
+      let x = Construct.src 1 fminus in
+      let yminus = Construct.tgt 1 fminus in
+      let yplus = Construct.tgt 1 fplus in
+      let zminus = Construct.src 1 hminus in
+      let zplus = Construct.src 1 hplus in
+      let w = Construct.tgt 1 hminus in
+      let rec list_tgt_src ty =
+        match ty with
+        | Obj -> []
+        | Arr (a, u, v) -> (v, a) :: (u, a) :: list_tgt_src a
+        | _ -> assert false
+      in
+      let sub =
+        hbridge :: hplus :: hminus :: w :: gbridge :: gplus :: gminus :: zbridge
+        :: zplus :: zminus :: fbridge :: fplus :: fminus :: ybridge :: yplus
+        :: yminus :: x
+        :: list_tgt_src (snd w)
+      in
+      (* The call to sub_ps_to_sub is a bit of a hack, relying on the fact that all
+       checked terms use deBruijn. Further refactoring to be done in the kernel to
+       enforce this more statically *)
+      Construct.tm_app hex sub
+
+    let repad_one_step p_0 p_1 f q_0 q_1 g previous iota_minus iota_plus v sub =
+      let padding_0, padding_1 = Tm.bdry previous in
+      hexcomp (Tm.constr p_0) (Tm.constr p_1)
+        Construct.(apply_sub (tm_app_sub previous iota_minus) sub)
+        (Tm.constr f)
+        Construct.(tm_app_sub (Functorialisation.tm padding_0 [ (v, 1) ]) sub)
+        Construct.(tm_app_sub (Functorialisation.tm padding_1 [ (v, 1) ]) sub)
+        Construct.(
+          inverse (tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sub))
+        Construct.(apply_sub (tm_app_sub previous iota_plus) sub)
+        (Tm.constr q_0) (Tm.constr q_1) (Tm.constr g)
 
-    val repadded : Tm.t
-    val f : Tm.t
-    val g : Tm.t
-  end
+    module type RepaddingDataS = sig
+      val f : int -> Tm.t
+      val g : int -> Tm.t
+    end
 
-  module Make (A : MakerS) : S = struct
-    module P1 = A.P1
-    module P2 = A.P2
+    module type RepaddedS = sig
+      val repad : int -> Tm.t
+    end
 
-    module D = struct
-      include A.D
+    module Repadded
+        (P1 : Padding.S)
+        (P2 : Padding.S)
+        (D : RepaddingDataS)
+        (Name : StringS) =
+    struct
+      let memo_repadded = Hashtbl.create 77
+
+      let rec repad i =
+        let compute_repadding i =
+          let repadding_constr =
+            if i = P1.F.min then Construct.id_n 1 (P1.F.v_constr i)
+            else
+              let previous = repad (i - 1) in
+              let sigma = P1.F.sub (i - 1) in
+              let f, g = (D.f (i - 1), D.g (i - 1)) in
+              repad_one_step
+                (P1.D.p (i - 1))
+                (P2.D.p (i - 1))
+                f
+                (P1.D.q (i - 1))
+                (P2.D.q (i - 1))
+                g previous
+                (P1.F.in_minus (i - 1))
+                (P1.F.in_plus (i - 1))
+                (P1.F.v (i - 1))
+                sigma
+          in
+          let name = (Printf.sprintf "%s.Repadding(%d)" Name.value i, 0, []) in
+          check_constr (P1.F.ctx i) ~name repadding_constr
+        in
+        match Hashtbl.find_opt memo_repadded i with
+        | Some t -> t
+        | None ->
+            let repadded = compute_repadding i in
+            Hashtbl.add memo_repadded i repadded;
+            repadded
+    end
 
-      let memo_f : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
-      let memo_g : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+    module type CanonicalRepaddingDataArgsS = sig
+      val ps : int -> ps
+      val incl : int -> constr list
+    end
 
+    module CanonicalRepaddingData
+        (Args : CanonicalRepaddingDataArgsS)
+        (P1 : Padding.S)
+        (P2 : Padding.S)
+        (R : RepaddedS)
+        (Name : StringS) : RepaddingDataS = struct
       let f i =
-        match Hashtbl.find_opt memo_f i with
-        | Some padded -> padded
-        | None ->
-            let padded = f i in
-            Hashtbl.add memo_f i padded;
-            padded
+        let ty =
+          Construct.(
+            arr
+              (wcomp
+                 (Construct.develop (Tm.constr (P1.D.p i)))
+                 i
+                 (tm_app_sub (R.repad i)
+                    (Unchecked.sub_apply_sub (P1.F.in_minus i) (P1.F.sub i))))
+              (Construct.develop (Tm.constr (P2.D.p i))))
+        in
+        let name = (Printf.sprintf "%s.f(%d)" Name.value i, 0, []) in
+        let coh = check_coh (Args.ps i) ty name in
+        check_constr (P1.F.ctx i) (Construct.coh_app coh (Args.incl i))
 
       let g i =
-        match Hashtbl.find_opt memo_g i with
-        | Some padded -> padded
-        | None ->
-            let padded = g i in
-            Hashtbl.add memo_g i padded;
-            padded
+        let ty =
+          Construct.(
+            arr
+              (Construct.develop (Tm.constr (P1.D.q i)))
+              (wcomp
+                 (tm_app_sub (R.repad i)
+                    (Unchecked.sub_apply_sub (P1.F.in_plus i) (P1.F.sub i)))
+                 i
+                 (Construct.develop (Tm.constr (P2.D.q i)))))
+        in
+        let name = (Printf.sprintf "%s.g(%d)" Name.value i, 0, []) in
+        let coh = check_coh (Args.ps i) ty name in
+        check_constr (P1.F.ctx i) (Construct.coh_app coh (Args.incl i))
     end
 
-    module R = A.R
+    module type MakerS = sig
+      module P1 : Padding.S
+      module P2 : Padding.S
+      module D : RepaddingDataS
+      module R : RepaddedS
 
-    let name = A.name
-    let repadded = R.repad P1.F.max
-    let f = D.f (P1.F.max - 1)
-    let g = D.g (P1.F.max - 1)
-  end
+      val name : string
+    end
 
-  module type MakerCanonicalS = sig
-    module P1 : Padding.S
-    module P2 : Padding.S
-    module D : CanonicalRepaddingDataArgsS
+    module type S = sig
+      include MakerS
 
-    val name : string
-  end
+      val repadded : Tm.t
+      val f : Tm.t
+      val g : Tm.t
+    end
+
+    module Make (A : MakerS) : S = struct
+      module P1 = A.P1
+      module P2 = A.P2
+
+      module D = struct
+        include A.D
+
+        let memo_f : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+        let memo_g : (int, Tm.t) Hashtbl.t = Hashtbl.create 77
+
+        let f i =
+          match Hashtbl.find_opt memo_f i with
+          | Some padded -> padded
+          | None ->
+              let padded = f i in
+              Hashtbl.add memo_f i padded;
+              padded
+
+        let g i =
+          match Hashtbl.find_opt memo_g i with
+          | Some padded -> padded
+          | None ->
+              let padded = g i in
+              Hashtbl.add memo_g i padded;
+              padded
+      end
+
+      module R = A.R
+
+      let name = A.name
+      let repadded = R.repad P1.F.max
+      let f = D.f (P1.F.max - 1)
+      let g = D.g (P1.F.max - 1)
+    end
 
-  module MakeCanonical (A : MakerCanonicalS) : S = Make (struct
-    module P1 = A.P1
-    module P2 = A.P2
+    module type MakerCanonicalS = sig
+      module P1 : Padding.S
+      module P2 : Padding.S
+      module D : CanonicalRepaddingDataArgsS
 
-    module Name = struct
-      let value = A.name
+      val name : string
     end
 
-    let name = A.name
+    module MakeCanonical (A : MakerCanonicalS) : S = Make (struct
+      module P1 = A.P1
+      module P2 = A.P2
 
-    module rec D : RepaddingDataS =
-      CanonicalRepaddingData (A.D) (P1) (P2) (R) (Name)
+      module Name = struct
+        let value = A.name
+      end
 
-    and R : RepaddedS = Repadded (P1) (P2) (D) (Name)
-  end)
+      let name = A.name
+
+      module rec D : RepaddingDataS =
+        CanonicalRepaddingData (A.D) (P1) (P2) (R) (Name)
+
+      and R : RepaddedS = Repadded (P1) (P2) (D) (Name)
+    end)
+  end
 end
diff --git a/lib/meta_operations/padding.mli b/lib/meta_operations/padding.mli
index bf653101..ae6be545 100644
--- a/lib/meta_operations/padding.mli
+++ b/lib/meta_operations/padding.mli
@@ -1,140 +1,145 @@
 open Common
-open Kernel
 
-module type StringS = sig
-  val value : string
-end
-
-module Filtration : sig
-  (* Data needed to define a filtration *)
-  module type MakerS = sig
-    val min : int
-    val max : int
-    val ctx : int -> ctx
-    val v : int -> Var.t
-  end
-
-  (* Data of the filtration *)
-  module type S = sig
-    include MakerS
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-    val sub : int -> sub
-    val v_constr : int -> constr
-    val src_v : int -> constr
-    val tgt_v : int -> constr
-    val v_plus : int -> Var.t
-    val v_bridge : int -> Var.t
-    val in_plus : int -> sub
-    val in_minus : int -> sub
+  module type StringS = sig
+    val value : string
   end
 
-  module Make (_ : MakerS) : S
-end
-
-module Padding : sig
-  module type PaddingDataS = sig
-    val p : int -> Tm.t
-    val q : int -> Tm.t
-  end
-
-  module type PaddedS = sig
-    val padded : int -> Tm.t
-  end
-
-  module type CanonicalPaddingDataArgsS = sig
-    val ps : int -> ps
-    val p_src : int -> constr
-    val q_tgt : int -> constr
-    val p_inc : int -> constr list
-    val q_inc : int -> constr list
-    val pad_in_ps : int -> sub
-  end
-
-  module type MakerS = sig
-    module F : Filtration.S
-    module D : PaddingDataS
-    module P : PaddedS
-
-    val name : string
+  module Filtration : sig
+    (* Data needed to define a filtration *)
+    module type MakerS = sig
+      val min : int
+      val max : int
+      val ctx : int -> ctx
+      val v : int -> Var.t
+    end
+
+    (* Data of the filtration *)
+    module type S = sig
+      include MakerS
+
+      val sub : int -> sub
+      val v_constr : int -> constr
+      val src_v : int -> constr
+      val tgt_v : int -> constr
+      val v_plus : int -> Var.t
+      val v_bridge : int -> Var.t
+      val in_plus : int -> sub
+      val in_minus : int -> sub
+    end
+
+    module Make (_ : MakerS) : S
   end
 
-  module type S = sig
-    include MakerS
-
-    val ctx : ctx
-    val v : Var.t
-    val v_constr : constr
-    val v_plus : Var.t
-    val v_bridge : Var.t
-    val p : Tm.t
-    val q : Tm.t
-    val padded : Tm.t
-    val padded_func : int -> int -> Tm.t
+  module Padding : sig
+    module type PaddingDataS = sig
+      val p : int -> Tm.t
+      val q : int -> Tm.t
+    end
+
+    module type PaddedS = sig
+      val padded : int -> Tm.t
+    end
+
+    module type CanonicalPaddingDataArgsS = sig
+      val ps : int -> ps
+      val p_src : int -> constr
+      val q_tgt : int -> constr
+      val p_inc : int -> constr list
+      val q_inc : int -> constr list
+      val pad_in_ps : int -> sub
+    end
+
+    module type MakerS = sig
+      module F : Filtration.S
+      module D : PaddingDataS
+      module P : PaddedS
+
+      val name : string
+    end
+
+    module type S = sig
+      include MakerS
+
+      val ctx : ctx
+      val v : Var.t
+      val v_constr : constr
+      val v_plus : Var.t
+      val v_bridge : Var.t
+      val p : Tm.t
+      val q : Tm.t
+      val padded : Tm.t
+      val padded_func : int -> int -> Tm.t
+    end
+
+    module Make (_ : MakerS) : S
+
+    module type MakerCanonicalS = sig
+      module F : Filtration.S
+      module D : CanonicalPaddingDataArgsS
+
+      val name : string
+    end
+
+    module MakeCanonical (_ : MakerCanonicalS) : S
   end
 
-  module Make (_ : MakerS) : S
-
-  module type MakerCanonicalS = sig
-    module F : Filtration.S
-    module D : CanonicalPaddingDataArgsS
-
+  module type FiltrationMorphismS = sig
+    val sub : int -> sub
     val name : string
   end
 
-  module MakeCanonical (_ : MakerCanonicalS) : S
-end
+  module PaddingApp
+      (_ : Filtration.S)
+      (_ : FiltrationMorphismS)
+      (_ : Padding.S) : Padding.S
 
-module type FiltrationMorphismS = sig
-  val sub : int -> sub
-  val name : string
-end
-
-module PaddingApp (_ : Filtration.S) (_ : FiltrationMorphismS) (_ : Padding.S) :
-  Padding.S
+  module Suspend (_ : Padding.S) : Padding.S
 
-module Suspend (_ : Padding.S) : Padding.S
+  module Repadding : sig
+    module type RepaddingDataS = sig
+      val f : int -> Tm.t
+      val g : int -> Tm.t
+    end
 
-module Repadding : sig
-  module type RepaddingDataS = sig
-    val f : int -> Tm.t
-    val g : int -> Tm.t
-  end
+    module type RepaddedS = sig
+      val repad : int -> Tm.t
+    end
 
-  module type RepaddedS = sig
-    val repad : int -> Tm.t
-  end
+    module type CanonicalRepaddingDataArgsS = sig
+      val ps : int -> ps
+      val incl : int -> constr list
+    end
 
-  module type CanonicalRepaddingDataArgsS = sig
-    val ps : int -> ps
-    val incl : int -> constr list
-  end
+    module type MakerS = sig
+      module P1 : Padding.S
+      module P2 : Padding.S
+      module D : RepaddingDataS
+      module R : RepaddedS
 
-  module type MakerS = sig
-    module P1 : Padding.S
-    module P2 : Padding.S
-    module D : RepaddingDataS
-    module R : RepaddedS
+      val name : string
+    end
 
-    val name : string
-  end
+    module type S = sig
+      include MakerS
 
-  module type S = sig
-    include MakerS
+      val repadded : Tm.t
+      val f : Tm.t
+      val g : Tm.t
+    end
 
-    val repadded : Tm.t
-    val f : Tm.t
-    val g : Tm.t
-  end
+    module Make (_ : MakerS) : S
 
-  module Make (_ : MakerS) : S
+    module type MakerCanonicalS = sig
+      module P1 : Padding.S
+      module P2 : Padding.S
+      module D : CanonicalRepaddingDataArgsS
 
-  module type MakerCanonicalS = sig
-    module P1 : Padding.S
-    module P2 : Padding.S
-    module D : CanonicalRepaddingDataArgsS
+      val name : string
+    end
 
-    val name : string
+    module MakeCanonical (_ : MakerCanonicalS) : S
   end
-
-  module MakeCanonical (_ : MakerCanonicalS) : S
 end
diff --git a/lib/meta_operations/ps_reduction.ml b/lib/meta_operations/ps_reduction.ml
index db0dd9d0..329a11c6 100644
--- a/lib/meta_operations/ps_reduction.ml
+++ b/lib/meta_operations/ps_reduction.ml
@@ -1,35 +1,39 @@
 open Common
-open Kernel
 
-let tdb i = Var (Var.Db i)
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
 
-let rec reduce i ps =
-  match (i, ps) with
-  | _, Br [] -> Br []
-  | 0, _ -> Br [ Br [] ]
-  | i, Br l -> Br (List.map (reduce (i - 1)) l)
+  let tdb i = Var (Var.Db i)
 
-let reduction_sub ps =
-  let rec aux i ps =
+  let rec reduce i ps =
     match (i, ps) with
-    | _, Br [] -> [ (tdb 0, true) ]
-    | 0, Br [ Br [] ] -> [ (tdb 2, true); (tdb 1, false); (tdb 0, false) ]
-    | 0, Br l ->
-        let k = List.length l in
-        [
-          (Coh (Builtin.comp_n k, Unchecked.(identity_ps (Br l))), true);
-          (tdb ((2 * k) - 1), false);
-          (tdb 0, false);
-        ]
-    | i, Br l -> Unchecked.suspwedge_subs_ps (List.map (aux (i - 1)) l) l
-  in
-  aux (Unchecked.dim_ps ps - 1) ps
+    | _, Br [] -> Br []
+    | 0, _ -> Br [ Br [] ]
+    | i, Br l -> Br (List.map (reduce (i - 1)) l)
 
-let coh c =
-  let ps, _, name = Coh.forget c in
-  let name = Printing.full_name name in
-  let ps = reduce (Unchecked.dim_ps ps - 1) ps in
-  if Coh.is_inv c then Error.fatal "cannot reduce invertible coherences"
-  else
-    let src, tgt, _ = Coh.noninv_srctgt c in
-    Coh.check_noninv ps src tgt (name ^ "_red", 0, [])
+  let reduction_sub ps =
+    let rec aux i ps =
+      match (i, ps) with
+      | _, Br [] -> [ (tdb 0, true) ]
+      | 0, Br [ Br [] ] -> [ (tdb 2, true); (tdb 1, false); (tdb 0, false) ]
+      | 0, Br l ->
+          let k = List.length l in
+          [
+            (Coh (Builtin.comp_n k, Unchecked.(identity_ps (Br l))), true);
+            (tdb ((2 * k) - 1), false);
+            (tdb 0, false);
+          ]
+      | i, Br l -> Unchecked.suspwedge_subs_ps (List.map (aux (i - 1)) l) l
+    in
+    aux (Unchecked.dim_ps ps - 1) ps
+
+  let coh c =
+    let ps, _, name = Coh.forget c in
+    let name = Printing.full_name name in
+    let ps = reduce (Unchecked.dim_ps ps - 1) ps in
+    if Coh.is_inv c then Error.fatal "cannot reduce invertible coherences"
+    else
+      let src, tgt, _ = Coh.noninv_srctgt c in
+      Coh.check_noninv ps src tgt (name ^ "_red", 0, [])
+end
diff --git a/lib/meta_operations/ps_reduction.mli b/lib/meta_operations/ps_reduction.mli
index 99de1b40..bf1fcb69 100644
--- a/lib/meta_operations/ps_reduction.mli
+++ b/lib/meta_operations/ps_reduction.mli
@@ -1,6 +1,9 @@
 open Common
-open Kernel
 
-val reduce : int -> ps -> ps
-val reduction_sub : ps -> sub_ps
-val coh : Coh.t -> Coh.t
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
+
+  val reduce : int -> ps -> ps
+  val reduction_sub : ps -> sub_ps
+  val coh : Coh.t -> Coh.t
+end
diff --git a/lib/meta_operations/suspension.ml b/lib/meta_operations/suspension.ml
index 6679a36d..c545966a 100644
--- a/lib/meta_operations/suspension.ml
+++ b/lib/meta_operations/suspension.ml
@@ -1,25 +1,27 @@
-open Kernel
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
 
-let rec iter_n_times n f base =
-  if n <= 0 then base else f (iter_n_times (n - 1) f base)
+  let rec iter_n_times n f base =
+    if n <= 0 then base else f (iter_n_times (n - 1) f base)
 
-let iter_option f n base =
-  match n with None -> base | Some n -> iter_n_times n f base
+  let iter_option f n base =
+    match n with None -> base | Some n -> iter_n_times n f base
 
-let pp_data = iter_option Unchecked.suspend_pp_data
-let ps = iter_option Unchecked.suspend_ps
-let ty = iter_option Unchecked.suspend_ty
-let tm = iter_option Unchecked.suspend_tm
-let sub_ps = iter_option Unchecked.suspend_sub_ps
-let ctx = iter_option Unchecked.suspend_ctx
-let sub = iter_option Unchecked.suspend_sub
+  let pp_data = iter_option Unchecked.suspend_pp_data
+  let ps = iter_option Unchecked.suspend_ps
+  let ty = iter_option Unchecked.suspend_ty
+  let tm = iter_option Unchecked.suspend_tm
+  let sub_ps = iter_option Unchecked.suspend_sub_ps
+  let ctx = iter_option Unchecked.suspend_ctx
+  let sub = iter_option Unchecked.suspend_sub
 
-let coh i coh =
-  match i with
-  | None | Some 0 -> coh
-  | Some _ -> Coh.apply_ps (ps i) (ty i) (pp_data i) coh
+  let coh i coh =
+    match i with
+    | None | Some 0 -> coh
+    | Some _ -> Coh.apply_ps (ps i) (ty i) (pp_data i) coh
 
-let checked_tm i t =
-  match i with
-  | None | Some 0 -> t
-  | Some _ -> fst (Tm.apply (ctx i) (tm i) (pp_data i) t)
+  let checked_tm i t =
+    match i with
+    | None | Some 0 -> t
+    | Some _ -> fst (Tm.apply (ctx i) (tm i) (pp_data i) t)
+end
diff --git a/lib/meta_operations/suspension.mli b/lib/meta_operations/suspension.mli
index 1c2c46eb..d08d71bd 100644
--- a/lib/meta_operations/suspension.mli
+++ b/lib/meta_operations/suspension.mli
@@ -1,11 +1,14 @@
 open Common
-open Kernel
 
-val ps : int option -> ps -> ps
-val ty : int option -> ty -> ty
-val tm : int option -> tm -> tm
-val sub_ps : int option -> sub_ps -> sub_ps
-val sub : int option -> sub -> sub
-val ctx : int option -> ctx -> ctx
-val coh : int option -> Coh.t -> Coh.t
-val checked_tm : int option -> Tm.t -> Tm.t
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
+
+  val ps : int option -> ps -> ps
+  val ty : int option -> ty -> ty
+  val tm : int option -> tm -> tm
+  val sub_ps : int option -> sub_ps -> sub_ps
+  val sub : int option -> sub -> sub
+  val ctx : int option -> ctx -> ctx
+  val coh : int option -> Coh.t -> Coh.t
+  val checked_tm : int option -> Tm.t -> Tm.t
+end
diff --git a/lib/meta_operations/telescope.ml b/lib/meta_operations/telescope.ml
index 0feb9885..2cb4cd24 100644
--- a/lib/meta_operations/telescope.ml
+++ b/lib/meta_operations/telescope.ml
@@ -1,189 +1,197 @@
 open Common
-open Kernel
 
-(* returns the associator pairing up the middle two cells of a composite of
+module Make (Theory : Theory.S) = struct
+  open Kernel.Make (Theory)
+  module Builtin = Builtin.Make (Theory)
+  module Suspension = Suspension.Make (Theory)
+  module Functorialisation = Functorialisation.Make (Theory)
+
+  (* returns the associator pairing up the middle two cells of a composite of
     (2*k) 1-cells. The argument is the integer k *)
-let middle_associator k =
-  let ps = Builtin.ps_comp (2 * k) in
-  let src = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
-  let tgt =
-    let sub_assoc_middle =
-      let rec compute_sub i =
-        match i with
-        | i when i <= 0 -> [ (Var (Db 0), false) ]
-        | i when i < k ->
-            (Var (Db (2 * i)), true)
-            :: (Var (Db ((2 * i) - 1)), false)
-            :: compute_sub (i - 1)
-        | i when i = k ->
-            let sub_comp =
-              [
-                (Var (Db ((2 * k) + 2)), true);
-                (Var (Db ((2 * k) + 1)), false);
-                (Var (Db (2 * k)), true);
-                (Var (Db ((2 * k) - 1)), false);
-                (Var (Db ((2 * k) - 3)), false);
-              ]
-            in
-            let comp = Coh (Builtin.comp_n 2, sub_comp) in
-            (comp, true)
-            :: (Var (Db ((2 * k) + 1)), false)
-            :: compute_sub (k - 1)
-        | i ->
-            (Var (Db ((2 * i) + 2)), true)
-            :: (Var (Db ((2 * i) + 1)), false)
-            :: compute_sub (i - 1)
+  let middle_associator k =
+    let ps = Builtin.ps_comp (2 * k) in
+    let src = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
+    let tgt =
+      let sub_assoc_middle =
+        let rec compute_sub i =
+          match i with
+          | i when i <= 0 -> [ (Var (Db 0), false) ]
+          | i when i < k ->
+              (Var (Db (2 * i)), true)
+              :: (Var (Db ((2 * i) - 1)), false)
+              :: compute_sub (i - 1)
+          | i when i = k ->
+              let sub_comp =
+                [
+                  (Var (Db ((2 * k) + 2)), true);
+                  (Var (Db ((2 * k) + 1)), false);
+                  (Var (Db (2 * k)), true);
+                  (Var (Db ((2 * k) - 1)), false);
+                  (Var (Db ((2 * k) - 3)), false);
+                ]
+              in
+              let comp = Coh (Builtin.comp_n 2, sub_comp) in
+              (comp, true)
+              :: (Var (Db ((2 * k) + 1)), false)
+              :: compute_sub (k - 1)
+          | i ->
+              (Var (Db ((2 * i) + 2)), true)
+              :: (Var (Db ((2 * i) + 1)), false)
+              :: compute_sub (i - 1)
+        in
+        compute_sub ((2 * k) - 1)
       in
-      compute_sub ((2 * k) - 1)
+      Coh (Builtin.comp_n ((2 * k) - 1), sub_assoc_middle)
     in
-    Coh (Builtin.comp_n ((2 * k) - 1), sub_assoc_middle)
-  in
-  Coh.check_inv ps src tgt ("focus", 0, [])
+    Coh.check_inv ps src tgt ("focus", 0, [])
 
-(* returns the unitor cancelling the identity in the middle of a composite of
+  (* returns the unitor cancelling the identity in the middle of a composite of
    (2*k+1) 1-cells. The argument is the integer k *)
-let middle_unitor k =
-  let ps = Builtin.ps_comp (2 * k) in
-  let src =
-    let sub_id_middle =
-      let rec compute_sub i =
-        match i with
-        | i when i <= 0 -> [ (Var (Db 0), false) ]
-        | i when i <= k ->
-            (Var (Db (2 * i)), true)
-            :: (Var (Db ((2 * i) - 1)), false)
-            :: compute_sub (i - 1)
-        | i when i = k + 1 ->
-            let id = Coh (Builtin.id (), [ (Var (Db ((2 * k) - 1)), false) ]) in
-            (id, true) :: (Var (Db ((2 * k) - 1)), false) :: compute_sub k
-        | i ->
-            (Var (Db ((2 * i) - 2)), true)
-            :: (Var (Db ((2 * i) - 3)), false)
-            :: compute_sub (i - 1)
+  let middle_unitor k =
+    let ps = Builtin.ps_comp (2 * k) in
+    let src =
+      let sub_id_middle =
+        let rec compute_sub i =
+          match i with
+          | i when i <= 0 -> [ (Var (Db 0), false) ]
+          | i when i <= k ->
+              (Var (Db (2 * i)), true)
+              :: (Var (Db ((2 * i) - 1)), false)
+              :: compute_sub (i - 1)
+          | i when i = k + 1 ->
+              let id =
+                Coh (Builtin.id (), [ (Var (Db ((2 * k) - 1)), false) ])
+              in
+              (id, true) :: (Var (Db ((2 * k) - 1)), false) :: compute_sub k
+          | i ->
+              (Var (Db ((2 * i) - 2)), true)
+              :: (Var (Db ((2 * i) - 3)), false)
+              :: compute_sub (i - 1)
+        in
+        compute_sub ((2 * k) + 1)
       in
-      compute_sub ((2 * k) + 1)
+      Coh (Builtin.comp_n ((2 * k) + 1), sub_id_middle)
     in
-    Coh (Builtin.comp_n ((2 * k) + 1), sub_id_middle)
-  in
-  let tgt = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
-  Coh.check_inv ps src tgt ("unit", 0, [])
+    let tgt = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
+    Coh.check_inv ps src tgt ("unit", 0, [])
 
-(* returns the whiskering rewriting the middle term of a composite of (2*k+1)
+  (* returns the whiskering rewriting the middle term of a composite of (2*k+1)
     1-cells. The argument is the integer k *)
-let middle_rewrite k =
-  let comp = Builtin.comp_n ((2 * k) + 1) in
-  let func_data = [ Var.Db ((2 * k) + 2) ] in
-  Functorialisation.coh_depth0 comp func_data
+  let middle_rewrite k =
+    let comp = Builtin.comp_n ((2 * k) + 1) in
+    let func_data = [ Var.Db ((2 * k) + 2) ] in
+    Functorialisation.coh_depth0 comp func_data
 
-let tdb i = Var (Db i)
-let cell_max k = Var.Db (4 * k)
-let cell_forward k = Var.Db ((4 * k) - 2)
-let cell_backward k = Var.Db ((4 * k) - 1)
-let obj k = if k <= 0 then Var.Db 0 else Var.Db ((4 * k) - 3)
-let type_cell_forward k = Arr (Obj, Var (obj (k - 1)), Var (obj k))
-let type_cell_backward k = Arr (Obj, Var (obj k), Var (obj (k - 1)))
+  let tdb i = Var (Db i)
+  let cell_max k = Var.Db (4 * k)
+  let cell_forward k = Var.Db ((4 * k) - 2)
+  let cell_backward k = Var.Db ((4 * k) - 1)
+  let obj k = if k <= 0 then Var.Db 0 else Var.Db ((4 * k) - 3)
+  let type_cell_forward k = Arr (Obj, Var (obj (k - 1)), Var (obj k))
+  let type_cell_backward k = Arr (Obj, Var (obj k), Var (obj (k - 1)))
 
-let type_cell_max k =
-  Arr
-    ( Arr (Obj, Var (obj (k - 1)), Var (obj (k - 1))),
-      Coh
-        ( Builtin.comp_n 2,
-          [
-            (Var (cell_backward k), true);
-            (Var (obj (k - 1)), false);
-            (Var (cell_forward k), true);
-            (Var (obj k), false);
-            (Var (obj (k - 1)), false);
-          ] ),
-      Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]) )
+  let type_cell_max k =
+    Arr
+      ( Arr (Obj, Var (obj (k - 1)), Var (obj (k - 1))),
+        Coh
+          ( Builtin.comp_n 2,
+            [
+              (Var (cell_backward k), true);
+              (Var (obj (k - 1)), false);
+              (Var (cell_forward k), true);
+              (Var (obj k), false);
+              (Var (obj (k - 1)), false);
+            ] ),
+        Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]) )
 
-let rec ctx k =
-  match k with
-  | k when k < 0 -> Error.fatal "cannot build context for the telescope"
-  | k when k = 0 -> [ (Var.Db 0, (Obj, false)) ]
-  | k ->
-      (cell_max k, (type_cell_max k, true))
-      :: (cell_backward k, (type_cell_backward k, false))
-      :: (cell_forward k, (type_cell_forward k, false))
-      :: (obj k, (Obj, false))
-      :: ctx (k - 1)
+  let rec ctx k =
+    match k with
+    | k when k < 0 -> Error.fatal "cannot build context for the telescope"
+    | k when k = 0 -> [ (Var.Db 0, (Obj, false)) ]
+    | k ->
+        (cell_max k, (type_cell_max k, true))
+        :: (cell_backward k, (type_cell_backward k, false))
+        :: (cell_forward k, (type_cell_forward k, false))
+        :: (obj k, (Obj, false))
+        :: ctx (k - 1)
 
-let rec subs_telescope_bdry ?(whisk = false) k =
-  match k with
-  | k when k <= 0 -> Error.fatal "telescopes must have positive length"
-  | k when k = 1 ->
-      ( [ (tdb 2, true); (tdb 1, false); (tdb 0, false) ],
-        [ (tdb 3, true); (tdb 0, false) ] )
-  | k ->
-      let right, left = subs_telescope_bdry ~whisk:false (k - 1) in
-      if whisk then
-        let src_max_var =
-          Coh
-            ( Builtin.comp_n 2,
+  let rec subs_telescope_bdry ?(whisk = false) k =
+    match k with
+    | k when k <= 0 -> Error.fatal "telescopes must have positive length"
+    | k when k = 1 ->
+        ( [ (tdb 2, true); (tdb 1, false); (tdb 0, false) ],
+          [ (tdb 3, true); (tdb 0, false) ] )
+    | k ->
+        let right, left = subs_telescope_bdry ~whisk:false (k - 1) in
+        if whisk then
+          let src_max_var =
+            Coh
+              ( Builtin.comp_n 2,
+                [
+                  (Var (cell_backward k), true);
+                  (Var (obj (k - 1)), false);
+                  (Var (cell_forward k), true);
+                  (Var (obj k), false);
+                  (Var (obj (k - 1)), false);
+                ] )
+          in
+          ( right,
+            List.append left
               [
-                (Var (cell_backward k), true);
-                (Var (obj (k - 1)), false);
-                (Var (cell_forward k), true);
-                (Var (obj k), false);
+                (Var (cell_max k), true);
+                (Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]), false);
+                (src_max_var, false);
                 (Var (obj (k - 1)), false);
               ] )
-        in
-        ( right,
-          List.append left
-            [
-              (Var (cell_max k), true);
-              (Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]), false);
-              (src_max_var, false);
-              (Var (obj (k - 1)), false);
-            ] )
-      else
-        ( (Var (cell_forward k), true) :: (Var (obj k), false) :: right,
-          List.append left
-            [ (Var (cell_backward k), true); (Var (obj (k - 1)), false) ] )
+        else
+          ( (Var (cell_forward k), true) :: (Var (obj k), false) :: right,
+            List.append left
+              [ (Var (cell_backward k), true); (Var (obj (k - 1)), false) ] )
 
-let sub_ps_telescope_bdry ?(whisk = false) k =
-  let right, left = subs_telescope_bdry ~whisk k in
-  List.append left right
+  let sub_ps_telescope_bdry ?(whisk = false) k =
+    let right, left = subs_telescope_bdry ~whisk k in
+    List.append left right
 
-let rec telescope k =
-  match k with
-  | k when k <= 0 -> Error.fatal "telescopes must have positive length"
-  | k when k = 1 -> tdb 4
-  | k ->
-      let comp = Suspension.coh (Some 1) (Builtin.comp_n 4) in
-      let tm_src_tgt coh sub_ps =
-        let t, u = (Coh.src coh, Coh.tgt coh) in
-        let sub = Unchecked.sub_ps_to_sub sub_ps in
-        let t = Unchecked.tm_apply_sub t sub in
-        let u = Unchecked.tm_apply_sub u sub in
-        (Coh (coh, sub_ps), t, u)
-      in
-      let m3, src_m3, tgt_m3 =
-        tm_src_tgt (middle_unitor (k - 1)) (sub_ps_telescope_bdry (k - 1))
-      in
-      let m2 =
-        Coh (middle_rewrite (k - 1), sub_ps_telescope_bdry ~whisk:true k)
-      in
-      let m1, src_m1, tgt_m1 =
-        tm_src_tgt (middle_associator k) (sub_ps_telescope_bdry k)
-      in
-      let sub_telescope =
-        [
-          (telescope (k - 1), true);
-          (Coh (Builtin.id (), [ (tdb 0, true) ]), false);
-          (m3, true);
-          (tgt_m3, false);
-          (m2, true);
-          (src_m3, false);
-          (m1, true);
-          (tgt_m1, false);
-          (src_m1, false);
-          (tdb 0, false);
-          (tdb 0, false);
-        ]
-      in
-      Coh (comp, sub_telescope)
+  let rec telescope k =
+    match k with
+    | k when k <= 0 -> Error.fatal "telescopes must have positive length"
+    | k when k = 1 -> tdb 4
+    | k ->
+        let comp = Suspension.coh (Some 1) (Builtin.comp_n 4) in
+        let tm_src_tgt coh sub_ps =
+          let t, u = (Coh.src coh, Coh.tgt coh) in
+          let sub = Unchecked.sub_ps_to_sub sub_ps in
+          let t = Unchecked.tm_apply_sub t sub in
+          let u = Unchecked.tm_apply_sub u sub in
+          (Coh (coh, sub_ps), t, u)
+        in
+        let m3, src_m3, tgt_m3 =
+          tm_src_tgt (middle_unitor (k - 1)) (sub_ps_telescope_bdry (k - 1))
+        in
+        let m2 =
+          Coh (middle_rewrite (k - 1), sub_ps_telescope_bdry ~whisk:true k)
+        in
+        let m1, src_m1, tgt_m1 =
+          tm_src_tgt (middle_associator k) (sub_ps_telescope_bdry k)
+        in
+        let sub_telescope =
+          [
+            (telescope (k - 1), true);
+            (Coh (Builtin.id (), [ (tdb 0, true) ]), false);
+            (m3, true);
+            (tgt_m3, false);
+            (m2, true);
+            (src_m3, false);
+            (m1, true);
+            (tgt_m1, false);
+            (src_m1, false);
+            (tdb 0, false);
+            (tdb 0, false);
+          ]
+        in
+        Coh (comp, sub_telescope)
 
-let checked k =
-  let name = "builtin_telescope" ^ string_of_int k in
-  check_term (Ctx.check (ctx k)) ~name:(name, 0, []) (telescope k)
+  let checked k =
+    let name = "builtin_telescope" ^ string_of_int k in
+    check_term (Ctx.check (ctx k)) ~name:(name, 0, []) (telescope k)
+end
diff --git a/lib/meta_operations/telescope.mli b/lib/meta_operations/telescope.mli
index dd8e4edf..835cebf0 100644
--- a/lib/meta_operations/telescope.mli
+++ b/lib/meta_operations/telescope.mli
@@ -1,5 +1,7 @@
-open Kernel
+module Make (Theory : Theory.S) : sig
+  open Kernel.Make(Theory)
 
-val ctx : int -> ctx
-val telescope : int -> tm
-val checked : int -> Tm.t
+  val ctx : int -> ctx
+  val telescope : int -> tm
+  val checked : int -> Tm.t
+end
diff --git a/lib/prover.ml b/lib/prover.ml
index 4edbd032..1d99df52 100644
--- a/lib/prover.ml
+++ b/lib/prover.ml
@@ -33,10 +33,7 @@ let read_file_to_string path =
   String.concat "\n" (read_stream stream)
 
 let parse_file f = parse (read_file_to_string f)
-
-let reset () =
-  Environment.reset ();
-  Settings.reset ()
+let reset () = Settings.reset ()
 
 (** Initialize the prover. *)
 let init () = Printf.printf "=^.^= "
diff --git a/rocq_plugin/src/export.ml b/rocq_plugin/src/export.ml
index 67937e04..a639113f 100644
--- a/rocq_plugin/src/export.ml
+++ b/rocq_plugin/src/export.ml
@@ -1,9 +1,7 @@
 open Names
 open EConstr
-open Evd
 open Catt
 open Common
-open Kernel
 
 let run_catt_on_file f =
   Prover.reset ();
@@ -45,35 +43,37 @@ let clean_name s =
       | c -> c)
     s
 
-module Translate : sig
-  val tm : Environ.env -> evar_map -> Tm.t -> unit
-  val coh : Environ.env -> evar_map -> Coh.t -> unit
-end = struct
-  let tbl : (Environment.value, string) Hashtbl.t = Hashtbl.create 97
+module type TranslateS = sig
+  val catt_tm : string -> unit
+end
+
+let tbl : (string, string) Hashtbl.t = Hashtbl.create 97
 
-  let retrieve_lambda value sigma =
+module Translate (Environment : Environments.S) : TranslateS = struct
+  open Environment
+
+  let retrieve_lambda catt_name sigma =
     let build_econstr name =
-      let gr = Rocqlib.lib_ref ("catt_" ^ name) in
+      let gr = Rocqlib.lib_ref name in
       let env = Global.env () in
       let sigma, econstr = Evd.fresh_global env sigma gr in
       (env, sigma, econstr)
     in
-    Option.map build_econstr (Hashtbl.find_opt tbl value)
+    Option.map build_econstr (Hashtbl.find_opt tbl catt_name)
 
-  let register name env sigma body value =
+  let register catt_name env sigma body value =
     let sigma, body = Typing.solve_evars env sigma body in
     let body = Evarutil.nf_evar sigma body in
     let info = Declare.Info.make () in
-    let cinfo =
-      Declare.CInfo.make ~name:(Id.of_string ("catt_" ^ name)) ~typ:None ()
-    in
+    let name = "catt_" ^ catt_name in
+    let cinfo = Declare.CInfo.make ~name:(Id.of_string name) ~typ:None () in
     let gr =
       Declare.declare_definition ~info ~cinfo ~opaque:false ~body sigma
     in
-    Rocqlib.register_ref Local ("catt_" ^ name) gr;
+    Rocqlib.register_ref Local name gr;
     let env = Global.env () in
     let sigma, econstr = Evd.fresh_global env sigma gr in
-    let _ = Hashtbl.add tbl value name in
+    let _ = Hashtbl.add tbl catt_name name in
     (env, sigma, econstr)
 
   let catt_to_coq_db ctx var =
@@ -214,12 +214,12 @@ end = struct
 
   (* translate a coherence into a coq function term *)
   and coh_to_lambda env sigma obj_type eq_type refl coh =
+    let ps, ty, name = Coh.forget coh in
+    let catt_name = "coh_" ^ clean_name (Printing.full_name name) in
     let value = Environment.Coh coh in
-    match retrieve_lambda value sigma with
+    match retrieve_lambda catt_name sigma with
     | Some res -> res
     | None ->
-        let ps, ty, name = Coh.forget coh in
-        let name = clean_name (Printing.full_name name) in
         let ctx = Unchecked.ps_to_ctx ps in
         let l_ind = induction_vars ps in
         let l_ind = induction_data l_ind ctx in
@@ -266,18 +266,19 @@ end = struct
         let sigma, body =
           ctx_to_lambda env sigma obj_type eq_type refl ctx (body l_ind ty)
         in
-        register ("coh_" ^ name) env sigma body value
+        register catt_name env sigma body value
 
   and tm_to_lambda ?name env sigma obj_type eq_type refl tm =
+    let name =
+      match Tm.full_name tm with
+      | Some name -> clean_name name
+      | None -> anon ()
+    in
+    let catt_name = "tm_" ^ name in
     let value = Environment.Tm tm in
-    match retrieve_lambda value sigma with
+    match retrieve_lambda catt_name sigma with
     | Some res -> res
     | None ->
-        let name =
-          match Tm.full_name tm with
-          | Some name -> clean_name name
-          | None -> anon ()
-        in
         let ctx = Tm.ctx tm in
         let tm = Tm.develop tm in
         let env, sigma, tm =
@@ -286,7 +287,7 @@ end = struct
         let sigma, body =
           ctx_to_lambda env sigma obj_type eq_type refl ctx tm
         in
-        register ("tm_" ^ name) env sigma body value
+        register catt_name env sigma body value
 
   let tm env sigma tm =
     let sigma, obj_type = Evarutil.new_Type sigma in
@@ -299,15 +300,21 @@ end = struct
     let sigma, eq_type = c_Q env sigma in
     let sigma, refl = c_R env sigma in
     ignore (coh_to_lambda env sigma obj_type eq_type refl coh)
-end
 
-let catt_tm file tm_names =
-  run_catt_on_file file;
-  let register_tm tm_name =
+  let catt_tm tm_name =
     let env = Global.env () in
     let sigma = Evd.from_env env in
     match Environment.val_var (Var.Name tm_name) with
-    | Coh c -> Translate.coh env sigma c
-    | Tm tm -> Translate.tm env sigma tm
+    | Coh c -> coh env sigma c
+    | Tm t -> tm env sigma t
+end
+
+let catt_tm file tm_names =
+  run_catt_on_file file;
+  let env =
+    List.hd (Environments.find_environment (Var.Name (List.hd tm_names)))
   in
+  let module Env = (val env : Environments.S) in
+  let module Translate = Translate (Env) in
+  let register_tm tm_name = Translate.catt_tm tm_name in
   List.iter register_tm tm_names

From c16261fb3d0683ff464f6e509767e9ce659f69a6 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 24 Oct 2025 13:04:12 +0200
Subject: [PATCH 22/30] add invertibility setting

---
 examples/inv.catt          |  4 +++
 lib/internals/fullness.ml  | 49 +++++++++++++++++++++++++++++++++++
 lib/internals/fullness.mli | 29 +++++++++++++++++++++
 lib/internals/kernel.ml    | 50 +++++++++++++++++++-----------------
 lib/lib/command.ml         | 52 ++++++++++++++++++++++++++------------
 lib/lib/command.mli        |  3 +++
 lib/lib/environments.ml    |  7 +----
 lib/parser/lexer.mll       |  2 ++
 lib/parser/parser.mly      |  4 ++-
 9 files changed, 154 insertions(+), 46 deletions(-)
 create mode 100644 examples/inv.catt
 create mode 100644 lib/internals/fullness.ml
 create mode 100644 lib/internals/fullness.mli

diff --git a/examples/inv.catt b/examples/inv.catt
new file mode 100644
index 00000000..6dd67db5
--- /dev/null
+++ b/examples/inv.catt
@@ -0,0 +1,4 @@
+theory invertibility 1
+
+coh comp_test (x(f)y(g)z) : x -> z
+coh inv (x(f(a)g)y) : g -> f
diff --git a/lib/internals/fullness.ml b/lib/internals/fullness.ml
new file mode 100644
index 00000000..1637b8e3
--- /dev/null
+++ b/lib/internals/fullness.ml
@@ -0,0 +1,49 @@
+open Common
+
+module Make
+    (Theory : Theory.S)
+    (Sub : sig
+      type t
+    end)
+    (PS : sig
+      type t
+
+      val source : t -> Sub.t
+      val target : t -> Sub.t
+    end)
+    (Tm : sig
+      type t
+
+      val preimage : t -> Sub.t -> t
+      val contains_all_vars : t -> bool
+    end)
+    (Ty : sig
+      type t
+
+      val dim : t -> int
+      val retrieve_arrow : t -> Tm.t * Tm.t
+      val contains_all_vars : t -> bool
+    end) =
+struct
+  type res = Inv | NonInv of Tm.t * Tm.t | No
+
+  let check ps t =
+    let needs_check =
+      match Theory.theory.invertibility with
+      | None -> true
+      | Some d when d >= Ty.dim t -> true
+      | _ -> false
+    in
+    if (not needs_check) || Ty.contains_all_vars t then Inv
+    else
+      try
+        let src, tgt = Ty.retrieve_arrow t in
+        let src_inclusion = PS.source ps in
+        let src = Tm.preimage src src_inclusion in
+        if not (Tm.contains_all_vars src) then No
+        else
+          let tgt_inclusion = PS.target ps in
+          let tgt = Tm.preimage tgt tgt_inclusion in
+          if not (Tm.contains_all_vars tgt) then No else NonInv (src, tgt)
+      with NotInImage -> No
+end
diff --git a/lib/internals/fullness.mli b/lib/internals/fullness.mli
new file mode 100644
index 00000000..91c23356
--- /dev/null
+++ b/lib/internals/fullness.mli
@@ -0,0 +1,29 @@
+module Make : functor
+  (_ : Theory.S)
+  (Sub : sig
+     type t
+   end)
+  (PS : sig
+     type t
+
+     val source : t -> Sub.t
+     val target : t -> Sub.t
+   end)
+  (Tm : sig
+     type t
+
+     val preimage : t -> Sub.t -> t
+     val contains_all_vars : t -> bool
+   end)
+  (Ty : sig
+     type t
+
+     val dim : t -> int
+     val retrieve_arrow : t -> Tm.t * Tm.t
+     val contains_all_vars : t -> bool
+   end)
+  -> sig
+  type res = Inv | NonInv of Tm.t * Tm.t | No
+
+  val check : PS.t -> Ty.t -> res
+end
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index 9ed7363d..798f01aa 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -6,7 +6,7 @@ exception IsCoh
 exception InvalidSubTarget of string * string
 exception MetaVariable
 
-module Make (_ : Theory.S) = struct
+module Make (Theory : Theory.S) = struct
   (** Operations on substitutions. *)
   module rec Sub : sig
     type t
@@ -247,7 +247,7 @@ module Make (_ : Theory.S) = struct
         in
         let rec aux ps = function
           | (y, ty) :: (f, tf) :: l as l1 ->
-              let _, u, v =
+              let u, v =
                 try Ty.retrieve_arrow tf with IsObj -> raise Invalid
               in
               let fx, fy =
@@ -324,6 +324,7 @@ module Make (_ : Theory.S) = struct
 
     val to_string : t -> string
     val free_vars : t -> Var.t list
+    val contains_all_vars : t -> bool
     val is_full : t -> bool
     val is_obj : t -> bool
     val is_equal : t -> t -> bool
@@ -332,7 +333,7 @@ module Make (_ : Theory.S) = struct
     val forget : t -> (Coh.t, Tm.t) ty
     val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
     val apply_sub : t -> Sub.t -> t
-    val retrieve_arrow : t -> t * Tm.t * Tm.t
+    val retrieve_arrow : t -> Tm.t * Tm.t
     val under_type : t -> t
     val source : t -> Tm.t
     val target : t -> Tm.t
@@ -355,7 +356,11 @@ module Make (_ : Theory.S) = struct
     let is_obj t = t.e = Obj
 
     let retrieve_arrow ty =
-      match ty.e with Obj -> raise IsObj | Arr (a, u, v) -> (a, u, v)
+      match ty.e with
+      | Obj ->
+          Error.fatal
+            "calling source and target on a type that is not an arrow type"
+      | Arr (_, u, v) -> (u, v)
 
     let under_type ty =
       match ty.e with Obj -> raise IsObj | Arr (a, _, _) -> a
@@ -392,7 +397,9 @@ module Make (_ : Theory.S) = struct
       | Arr (t, u, v) ->
           List.unions [ free_vars t; Tm.free_vars u; Tm.free_vars v ]
 
-    let is_full t = List.included (Ctx.domain t.c) (free_vars t)
+    (* TODO: remove is_full *)
+    let contains_all_vars t = List.included (Ctx.domain t.c) (free_vars t)
+    let is_full t = contains_all_vars t
     let forget t = t.unchecked
     let to_string ty = Printing.ty_to_string (forget ty)
 
@@ -444,6 +451,7 @@ module Make (_ : Theory.S) = struct
 
     (* Variable uses *)
     val free_vars : t -> Var.t list
+    val contains_all_vars : t -> bool
     val is_full : t -> bool
 
     (* Production of terms *)
@@ -489,7 +497,11 @@ module Make (_ : Theory.S) = struct
       | Var x -> x :: fvty
       | Coh (_, sub) | App (_, sub) -> Sub.free_vars sub
 
-    let is_full tm = List.included (Ctx.domain (Ty.ctx tm.ty)) (free_vars tm)
+    (* TODO: remove is_full *)
+    let contains_all_vars tm =
+      List.included (Ctx.domain (Ty.ctx tm.ty)) (free_vars tm)
+
+    let is_full tm = contains_all_vars tm
     let forget tm = tm.unchecked
     let constr tm = (forget tm, ty tm)
 
@@ -664,23 +676,15 @@ module Make (_ : Theory.S) = struct
     let is_inv = function Inv (_, _) -> true | NonInv (_, _) -> false
 
     let algebraic ps ty name =
-      if Ty.is_full ty then (
-        Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
-        Inv ({ ps; ty }, name))
-      else
-        let _, src, tgt =
-          try Ty.retrieve_arrow ty with IsObj -> raise NotAlgebraic
-        in
-        try
-          let src_inclusion = PS.source ps in
-          let src = Tm.preimage src src_inclusion in
-          if not (Tm.is_full src) then raise NotAlgebraic
-          else
-            let tgt_inclusion = PS.target ps in
-            let tgt = Tm.preimage tgt tgt_inclusion in
-            if not (Tm.is_full tgt) then raise NotAlgebraic
-            else NonInv ({ ps; src; tgt; total_ty = ty }, name)
-        with NotInImage -> raise NotAlgebraic
+      let module Fullness = Fullness.Make (Theory) (Sub) (PS) (Tm) (Ty) in
+      match Fullness.check ps ty with
+      | Inv ->
+          Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
+          Inv ({ ps; ty }, name)
+      | NonInv (src, tgt) ->
+          Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
+          NonInv ({ ps; src; tgt; total_ty = ty }, name)
+      | No -> raise NotAlgebraic
 
     let check ps_unchkd t_unchkd ((name, _, _) as pp_data) =
       Io.info ~v:5
diff --git a/lib/lib/command.ml b/lib/lib/command.ml
index 6111992f..c5fff26c 100644
--- a/lib/lib/command.ml
+++ b/lib/lib/command.ml
@@ -5,6 +5,8 @@ exception UnknownOption of string
 exception NotAnInt of string
 exception NotABoolean of string
 
+type theory_setting = Invertibility of string
+
 (**toplevel commands. *)
 type cmd =
   | Coh of Var.t * (Var.t * tyR) list * tyR
@@ -13,26 +15,27 @@ type cmd =
   | Decl of Var.t * (Var.t * tyR) list * tmR * tyR option
   | Decl_builtin of Var.t * builtin
   | Set of string * string
+  | SetTheory of theory_setting
   | Benchmark of (Var.t * tyR) list * tmR
   | Benchmark_builtin of builtin
 
 type prog = cmd list
 type next = Abort | KeepGoing | Interactive | ChangeTheory of theory
 
+let parse_bool v =
+  match v with
+  | _ when String.equal v "t" -> true
+  | _ when String.equal v "true" -> true
+  | _ when String.equal v "1" -> true
+  | _ when String.equal v "f" -> false
+  | _ when String.equal v "false" -> false
+  | _ when String.equal v "0" -> false
+  | _ -> raise (NotABoolean v)
+
+let parse_int v =
+  match int_of_string_opt v with Some s -> s | None -> raise (NotAnInt v)
+
 let exec_set o v =
-  let parse_bool v =
-    match v with
-    | _ when String.equal v "t" -> true
-    | _ when String.equal v "true" -> true
-    | _ when String.equal v "1" -> true
-    | _ when String.equal v "f" -> false
-    | _ when String.equal v "false" -> false
-    | _ when String.equal v "0" -> false
-    | _ -> raise (NotABoolean v)
-  in
-  let parse_int v =
-    match int_of_string_opt v with Some s -> s | None -> raise (NotAnInt v)
-  in
   let _ =
     match o with
     | _ when String.equal o "explicit_substitutions" ->
@@ -57,9 +60,25 @@ let exec_set o v =
   in
   KeepGoing
 
-let _exec_set_theory d =
-  let t = { strictness = Weak; invertibility = d; postulates = [] } in
-  ChangeTheory t
+let exec_set_theory t setting =
+  match setting with
+  | Invertibility degree ->
+      let invertibility =
+        match degree with
+        | _ when String.equal degree "infinity" -> None
+        | _ ->
+            let d =
+              try parse_int degree
+              with NotAnInt degree ->
+                Error.wrong_option_argument ~expected:"an int or infinity"
+                  "invertibility" degree
+            in
+            Some d
+      in
+      let t =
+        { strictness = t.strictness; invertibility; postulates = t.postulates }
+      in
+      ChangeTheory t
 
 let show_menu () =
   Io.eprintf
@@ -170,6 +189,7 @@ functor
           | NotAnInt v -> Error.wrong_option_argument ~expected:"int" o v
           | NotABoolean v -> Error.wrong_option_argument ~expected:"boolean" o v
           )
+      | SetTheory s -> exec_set_theory CurrentTheory.theory s
       | Check_builtin b ->
           Io.command "check %s" (Raw.string_of_builtin b);
           let e, ty = exec_check_builtin b in
diff --git a/lib/lib/command.mli b/lib/lib/command.mli
index 559bc70d..2df6449e 100644
--- a/lib/lib/command.mli
+++ b/lib/lib/command.mli
@@ -1,6 +1,8 @@
 open Common
 open Raw_types
 
+type theory_setting = Invertibility of string
+
 type cmd =
   | Coh of Var.t * (Var.t * tyR) list * tyR
   | Check of (Var.t * tyR) list * tmR * tyR option
@@ -8,6 +10,7 @@ type cmd =
   | Decl of Var.t * (Var.t * tyR) list * tmR * tyR option
   | Decl_builtin of Var.t * builtin
   | Set of string * string
+  | SetTheory of theory_setting
   | Benchmark of (Var.t * tyR) list * tmR
   | Benchmark_builtin of builtin
 
diff --git a/lib/lib/environments.ml b/lib/lib/environments.ml
index fa147817..d685ebab 100644
--- a/lib/lib/environments.ml
+++ b/lib/lib/environments.ml
@@ -57,15 +57,10 @@ let update_known_environments (v : Var.t) env =
       Hashtbl.replace known_environments v (replace list)
 
 let store_environment environment =
-  Io.debug "updating the known environments";
   let open (val environment : S) in
   Environment.forall (fun v -> update_known_environments v environment)
 
-let find_environment v =
-  Io.debug "trying to find the variable %s" (Var.to_string v);
-  let res = Hashtbl.find known_environments v in
-  Io.debug "found environment";
-  res
+let find_environment v = Hashtbl.find known_environments v
 
 module Make (CurrentTheory : Theory.S) = struct
   module CurrentTheory = CurrentTheory
diff --git a/lib/parser/lexer.mll b/lib/parser/lexer.mll
index b35f0f8e..01eb46fc 100644
--- a/lib/parser/lexer.mll
+++ b/lib/parser/lexer.mll
@@ -36,6 +36,8 @@ rule token = parse
                                                                             EH_HALF(n,k,l) }
   | "declare" { DECLARE }
   | "benchmark" { BENCHMARK }
+  | "theory" { THEORY }
+  | "invertibility" { INVERTIBILITY }
   | "I" { INV }
   | "U" { UNIT }
   | "(" { LPAR }
diff --git a/lib/parser/parser.mly b/lib/parser/parser.mly
index 0d816f5b..ee55d327 100644
--- a/lib/parser/parser.mly
+++ b/lib/parser/parser.mly
@@ -42,7 +42,7 @@
 %token <int> CYLSTACK
 %token <string> IDENT
 %token <string> INT
-%token CHECK EQUAL LET IN SET INV UNIT DECLARE BENCHMARK
+%token CHECK EQUAL LET IN SET INV UNIT DECLARE BENCHMARK THEORY INVERTIBILITY
 %token EOF
 
 %start prog
@@ -79,6 +79,8 @@ cmd:
   | DECLARE IDENT EQUAL builtin { Decl_builtin (Var.make_var $2,$4) }
   | BENCHMARK args_or_ps EQUAL tmexpr { Benchmark ($2,$4) }
   | BENCHMARK builtin { Benchmark_builtin ($2) }
+  | THEORY INVERTIBILITY IDENT {SetTheory (Invertibility $3)}
+  | THEORY INVERTIBILITY INT {SetTheory (Invertibility $3)}
 
 args_of_same_ty :
   | IDENT COL tyexpr { [Var.make_var $1, $3], $3 }

From b40294d003e03371dc6a8017898d1661653ae91f Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 28 Oct 2025 13:30:15 +0100
Subject: [PATCH 23/30] add tests for invertibility

---
 test.t/features/invertible-theory.catt |  7 ++
 test.t/run.t                           | 96 +++++++++++++-------------
 2 files changed, 56 insertions(+), 47 deletions(-)
 create mode 100644 test.t/features/invertible-theory.catt

diff --git a/test.t/features/invertible-theory.catt b/test.t/features/invertible-theory.catt
new file mode 100644
index 00000000..0016c5aa
--- /dev/null
+++ b/test.t/features/invertible-theory.catt
@@ -0,0 +1,7 @@
+theory invertibility 1
+
+coh inv2 (x(f(a)g)y) : g -> f
+
+theory invertibility 0
+coh inv1 (x(f)y) : y -> x
+coh compinv (x(f)y(g)z) : z -> x
diff --git a/test.t/run.t b/test.t/run.t
index ae71b1fa..78597a78 100644
--- a/test.t/run.t
+++ b/test.t/run.t
@@ -400,6 +400,8 @@
   [=^.^=] let bug = (_builtin_id  x)
   [=I.I=] successfully defined term (builtin_id x) of type x -> x.
 
+  $ catt features/invertible-theory.catt
+
   $ catt coverage/eckmann-hilton-unoptimized.catt
   [=^.^=] coh comp3 = x1 -> x4
   [=I.I=] successfully defined comp3.
@@ -775,18 +777,18 @@
    let !3builtin_comp5_red = Coh([[[[[]]]]], .6 -> .7) in
    let !3builtin_comp5_red_func[(.10,1)]_op{5} = Coh([[[[[[]]]]]], !3builtin_comp5_red  (.8) -> !3builtin_comp5_red  (.9)) in
    let !4builtin_comp3 = Coh([[[[[[][][]]]]]], .8 -> .13) in
-   let !1BPad.Padding(1)_func[(.6,1)] = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) => .6 in 
-   let !1BPad.Padding(1)_func[(.4,1)]_op{1} = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) => .6 in 
-   let !1BPad.Padding(1) = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) (.4,.2 -> .3) => .4 in 
-   let !1BPad.Padding(1)_op{1} = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) (.4,.3 -> .2) => .4 in 
-   let !1UBPad.Padding(1)_func[(.5,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.2 -> .2} {.4,.2 -> .2} (.5,.3 -> .4) => .5 in 
+   let !1BPad.Padding(1)_func[(.6,1)] = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) => .6 in
+   let !1BPad.Padding(1)_func[(.4,1)]_op{1} = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) => .6 in
+   let !1BPad.Padding(1) = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) (.4,.2 -> .3) => .4 in
+   let !1BPad.Padding(1)_op{1} = λ{.0,*} {.1,*} (.2,.0 -> .1) (.3,.0 -> .1) (.4,.3 -> .2) => .4 in
+   let !1UBPad.Padding(1)_func[(.5,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.2 -> .2} {.4,.2 -> .2} (.5,.3 -> .4) => .5 in
    let !3builtin_id = Coh([[[[]]]], .6 -> .6) in
    let !3builtin_comp4 = Coh([[[[[][][][]]]]], .6 -> .13) in
    let !3builtin_comp4_func[(.16,1)] = Coh([[[[[][][][[]]]]]], !3builtin_comp4  (.8) (.10) (.12) (.14) -> !3builtin_comp4  (.8) (.10) (.12) (.15)) in
    let !3builtin_comp4_func[(.14,1)] = Coh([[[[[][][[]][]]]]], !3builtin_comp4  (.8) (.10) (.12) (.16) -> !3builtin_comp4  (.8) (.10) (.13) (.16)) in
    let !3builtin_comp4_func[(.12,1)] = Coh([[[[[][[]][][]]]]], !3builtin_comp4  (.8) (.10) (.14) (.16) -> !3builtin_comp4  (.8) (.11) (.14) (.16)) in
    let !3builtin_comp4_func[(.10,1)] = Coh([[[[[[]][][][]]]]], !3builtin_comp4  (.8) (.12) (.14) (.16) -> !3builtin_comp4  (.9) (.12) (.14) (.16)) in
-   let !1UBPad.Padding(1) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,.2 -> .2) => .3 in 
+   let !1UBPad.Padding(1) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,.2 -> .2) => .3 in
    let !3builtin_comp5 = Coh([[[[[][][][][]]]]], .6 -> .15) in
    let !3builtin_comp5_func[(.10,1)] = Coh([[[[[[]][][][][]]]]], !3builtin_comp5  (.8) (.12) (.14) (.16) (.18) -> !3builtin_comp5  (.9) (.12) (.14) (.16) (.18)) in
    let !3builtin_comp5_func[(.12,1)] = Coh([[[[[][[]][][][]]]]], !3builtin_comp5  (.8) (.10) (.14) (.16) (.18) -> !3builtin_comp5  (.8) (.11) (.14) (.16) (.18)) in
@@ -795,7 +797,7 @@
    let !3builtin_comp5_func[(.18,1)] = Coh([[[[[][][][][[]]]]]], !3builtin_comp5  (.8) (.10) (.12) (.14) (.16) -> !3builtin_comp5  (.8) (.10) (.12) (.14) (.17)) in
    let !2builtin_comp3_red = Coh([[[[]]]], .4 -> .5) in
    let !2builtin_comp3_red_func[(.8,1)] = Coh([[[[[]]]]], !2builtin_comp3_red  (.6) -> !2builtin_comp3_red  (.7)) in
-   let !2builtin_comp3_red_func[(.8,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) => !2builtin_comp3_red_func[(.8,1)]  (.8) in 
+   let !2builtin_comp3_red_func[(.8,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) => !2builtin_comp3_red_func[(.8,1)]  (.8) in
    let !2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5} = Coh([[[[[[]]]]]], !2builtin_comp3_red_func[(.8,1)]  (.8) -> !2builtin_comp3_red_func[(.8,1)]  (.9)) in
    let !3builtin_comp2 = Coh([[[[[][]]]]], .6 -> .9) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16)) (.18) -> !3builtin_comp5  (.8) (.10) (.12) (.14) (!3builtin_comp2  (.16) (.18))) in
@@ -812,101 +814,101 @@
    let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16) -> !3builtin_comp4  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16)) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16)) -> !3builtin_comp2  (!3builtin_comp4  (.8) (.10) (.12) (.14)) (.16)) in
    let intch_src^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp5  (.8) (.10) (.12) (.14) (.16)) (.18)) -> !3builtin_comp2  (!3builtin_comp5  (.8) (.10) (.12) (.14) (.16)) (.18)) in
-   let !3builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.4 -> .5} (.10,.7 -> .9) => !3builtin_comp2  (.8) (.10) in 
+   let !3builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.4 -> .5} (.10,.7 -> .9) => !3builtin_comp2  (.8) (.10) in
    let !3builtin_id^-1_func[(.8,1)] = Coh([[[[[]]]]], !3builtin_comp2  (.8) (!3builtin_id  (.7)) -> !3builtin_comp2  (!3builtin_id  (.6)) (.8)) in
    let !3builtin_comp2_func[(.10,1)] = Coh([[[[[[]][]]]]], !3builtin_comp2  (.8) (.12) -> !3builtin_comp2  (.9) (.12)) in
-   let !3builtin_comp2_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} {.8,.6 -> .7} {.9,.6 -> .7} (.10,.8 -> .9) {.11,.4 -> .5} (.12,.7 -> .11) => !3builtin_comp2_func[(.10,1)]  (.10) (.12) in 
+   let !3builtin_comp2_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} {.8,.6 -> .7} {.9,.6 -> .7} (.10,.8 -> .9) {.11,.4 -> .5} (.12,.7 -> .11) => !3builtin_comp2_func[(.10,1)]  (.10) (.12) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16) -> !3builtin_comp4  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16))) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][]]]]], !3builtin_comp4  (!3builtin_comp2  (.8) (.10)) (.12) (.14) (.16) -> !3builtin_comp4  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16)) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (!3builtin_comp2  (.8) (.10)) (.12) (.14) (.16) (.18) -> !3builtin_comp5  (.8) (!3builtin_comp2  (.10) (.12)) (.14) (.16) (.18)) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (.10) (!3builtin_comp2  (.12) (.14)) (.16) (.18) -> !3builtin_comp5  (.8) (.10) (.12) (!3builtin_comp2  (.14) (.16)) (.18)) in
    let !3builtin_assc^-1 = Coh([[[[[][][][][][]]]]], !3builtin_comp5  (.8) (.10) (.12) (.14) (!3builtin_comp2  (.16) (.18)) -> !3builtin_comp2  (!3builtin_comp5  (.8) (.10) (.12) (.14) (.16)) (.18)) in
    let !3builtin_comp2_func[(.12,1)] = Coh([[[[[][[]]]]]], !3builtin_comp2  (.8) (.10) -> !3builtin_comp2  (.8) (.11)) in
-   let !3builtin_comp2_func[(.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.4 -> .5} {.10,.7 -> .9} {.11,.7 -> .9} (.12,.10 -> .11) => !3builtin_comp2_func[(.12,1)]  (.8) (.12) in 
+   let !3builtin_comp2_func[(.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.4 -> .5} {.10,.7 -> .9} {.11,.7 -> .9} (.12,.10 -> .11) => !3builtin_comp2_func[(.12,1)]  (.8) (.12) in
    let !3assoc = Coh([[[[[][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp2  (.10) (.12)) -> !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12)) in
    let intch_src^-1 = Coh([[[[[][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12)) -> !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12)) in
    let intch_src^-1 = Coh([[[[[][]]]]], !2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp2  (.8) (.10)) -> !3builtin_comp2  (!2builtin_comp3_red_func[(.8,1)]  (.8)) (!2builtin_comp3_red_func[(.8,1)]  (.10))) in
    let !2builtin_comp2 = Coh([[[[][]]]], .4 -> .7) in
    let !2builtin_comp2_func[(.8,1)] = Coh([[[[[]][]]]], !2builtin_comp2  (.6) (.10) -> !2builtin_comp2  (.7) (.10)) in
-   let !2builtin_comp2_func[(.8,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} (.10,.5 -> .9) => !2builtin_comp2_func[(.8,1)]  (.8) (.10) in 
-   let !1!1builtin_comp2_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) {.7,.3 -> .2} (.8,.5 -> .7) => !2builtin_comp2  (.6) (.8) in 
+   let !2builtin_comp2_func[(.8,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} (.10,.5 -> .9) => !2builtin_comp2_func[(.8,1)]  (.8) (.10) in
+   let !1!1builtin_comp2_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) {.7,.3 -> .2} (.8,.5 -> .7) => !2builtin_comp2  (.6) (.8) in
    let !2builtin_comp2_func[(.8,1) (.12,1)] = Coh([[[[[]][[]]]]], !2builtin_comp2  (.6) (.10) -> !2builtin_comp2  (.7) (.11)) in
    let !2builtin_comp2_func[(.8,1) (.12,1)]_red_func[(.10,1) (.16,1)]_op{5} = Coh([[[[[[]]][[[]]]]]], !2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.14) -> !2builtin_comp2_func[(.8,1) (.12,1)]  (.9) (.15)) in
-   let !2builtin_comp2_func[(.8,1) (.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} {.10,.5 -> .9} {.11,.5 -> .9} (.12,.10 -> .11) => !2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.12) in 
+   let !2builtin_comp2_func[(.8,1) (.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} {.10,.5 -> .9} {.11,.5 -> .9} (.12,.10 -> .11) => !2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.12) in
    let intch_src^-1 = Coh([[[[[][]][[][]]]]], !2builtin_comp2_func[(.8,1) (.12,1)]  (!3builtin_comp2  (.8) (.10)) (!3builtin_comp2  (.14) (.16)) -> !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.14)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (.10) (.16))) in
    let intch_tgt^-1 = Coh([[[[[][]][[][]]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.14)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (.10) (.16)) -> !2builtin_comp2_func[(.8,1) (.12,1)]  (!3builtin_comp2  (.8) (.10)) (!3builtin_comp2  (.14) (.16))) in
    let !2builtin_comp2_func[(.10,1)] = Coh([[[[][[]]]]], !2builtin_comp2  (.6) (.8) -> !2builtin_comp2  (.6) (.9)) in
-   let !2builtin_comp2_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} {.8,.5 -> .7} {.9,.5 -> .7} (.10,.8 -> .9) => !2builtin_comp2_func[(.10,1)]  (.6) (.10) in 
-   let !2builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} (.8,.5 -> .7) => !2builtin_comp2  (.6) (.8) in 
+   let !2builtin_comp2_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} {.8,.5 -> .7} {.9,.5 -> .7} (.10,.8 -> .9) => !2builtin_comp2_func[(.10,1)]  (.6) (.10) in
+   let !2builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} (.8,.5 -> .7) => !2builtin_comp2  (.6) (.8) in
    let !2builtin_id = Coh([[[]]], .4 -> .4) in
-   let !1BToURepad.Repadding(1) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,.2 -> .2) => !2builtin_id  (.3) in 
+   let !1BToURepad.Repadding(1) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,.2 -> .2) => !2builtin_id  (.3) in
    let !2builtin_id^-1_func[(.6,1)] = Coh([[[[]]]], !2builtin_comp2  (.6) (!2builtin_id  (.5)) -> !2builtin_comp2  (!2builtin_id  (.4)) (.6)) in
    let !2builtin_id^-1^-1_func[(.8,2)] = Coh([[[[[]]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1)]  (.8) (!2builtin_id  (.5))) (!2builtin_id^-1_func[(.6,1)]  (.7)) -> !3builtin_comp2  (!2builtin_id^-1_func[(.6,1)]  (.6)) (!2builtin_comp2_func[(.10,1)]  (!2builtin_id  (.4)) (.8))) in
    let !1builtin_id = Coh([[]], .2 -> .2) in
    let !1builtin_comp2 = Coh([[[][]]], .2 -> .5) in
-   let !1builtin_comp2_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) {.5,.0 -> .1} (.6,.5 -> .3) => !1builtin_comp2  (.6) (.4) in 
+   let !1builtin_comp2_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) {.5,.0 -> .1} (.6,.5 -> .3) => !1builtin_comp2  (.6) (.4) in
    let !1BPad.p(1)_op{1} = Coh([[[]]], !1BPad.Padding(1)_op{1}  (.3) (.2) (!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.2))) -> .4) in
-   let tm_6 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)_op{1}  (.5) in 
+   let tm_6 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)_op{1}  (.5) in
    let !1BPad.p(1)_op{1} = Coh([[[]]], .4 -> !1BPad.Padding(1)_op{1}  (.3) (.2) (!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.2)))) in
-   let tm_5 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)_op{1}  (.4) in 
+   let tm_5 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)_op{1}  (.4) in
    let !1builtin_comp2_func[(.6,1) (.10,1)] = Coh([[[[]][[]]]], !1builtin_comp2  (.4) (.8) -> !1builtin_comp2  (.5) (.9)) in
    let !1builtin_comp2_func[(.8,2) (.14,2)] = Coh([[[[[]]][[[]]]]], !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.12) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.7) (.13)) in
-   let !1builtin_comp2_func[(.8,2) (.14,2)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.0 -> .1} {.10,.3 -> .9} {.11,.3 -> .9} {.12,.10 -> .11} {.13,.10 -> .11} (.14,.12 -> .13) => !1builtin_comp2_func[(.8,2) (.14,2)]  (.8) (.14) in 
+   let !1builtin_comp2_func[(.8,2) (.14,2)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.0 -> .1} {.10,.3 -> .9} {.11,.3 -> .9} {.12,.10 -> .11} {.13,.10 -> .11} (.14,.12 -> .13) => !1builtin_comp2_func[(.8,2) (.14,2)]  (.8) (.14) in
    let !1builtin_comp2_func[(.6,1) (.12,2)] = Coh([[[[]][[[]]]]], !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.11)) in
-   let !1builtin_comp2_func[(.6,1) (.12,2)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.3 -> .7} {.9,.3 -> .7} {.10,.8 -> .9} {.11,.8 -> .9} (.12,.10 -> .11) => !1builtin_comp2_func[(.6,1) (.12,2)]  (.6) (.12) in 
+   let !1builtin_comp2_func[(.6,1) (.12,2)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.3 -> .7} {.9,.3 -> .7} {.10,.8 -> .9} {.11,.8 -> .9} (.12,.10 -> .11) => !1builtin_comp2_func[(.6,1) (.12,2)]  (.6) (.12) in
    let !1builtin_comp2_func[(.8,2) (.12,1)] = Coh([[[[[]]][[]]]], !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.12) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.7) (.12)) in
-   let !1builtin_comp2_func[(.8,2) (.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.0 -> .1} {.10,.3 -> .9} {.11,.3 -> .9} (.12,.10 -> .11) => !1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (.12) in 
-   let !1builtin_comp2_func[(.4,1) (.8,1)]_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.7 -> .3} {.9,.7 -> .3} (.10,.8 -> .9) => !1builtin_comp2_func[(.6,1) (.10,1)]  (.10) (.6) in 
-   let !1builtin_comp2_func[(.6,1) (.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.3 -> .7} {.9,.3 -> .7} (.10,.8 -> .9) => !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10) in 
+   let !1builtin_comp2_func[(.8,2) (.12,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.0 -> .1} {.10,.3 -> .9} {.11,.3 -> .9} (.12,.10 -> .11) => !1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (.12) in
+   let !1builtin_comp2_func[(.4,1) (.8,1)]_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.3 -> .2} {.5,.3 -> .2} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.7 -> .3} {.9,.7 -> .3} (.10,.8 -> .9) => !1builtin_comp2_func[(.6,1) (.10,1)]  (.10) (.6) in
+   let !1builtin_comp2_func[(.6,1) (.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.0 -> .1} {.8,.3 -> .7} {.9,.3 -> .7} (.10,.8 -> .9) => !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10) in
    let !1intch(2,0) = Coh([[[[]][[]]]], !2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (!2builtin_id  (.8))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (.5)) (.10)) -> !1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (.10)) in
    let !1intch(2,0)^-1_func[(.8,1) (.14,1)] = Coh([[[[[]]][[[]]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (!2builtin_id  (.10))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (.5)) (.14))) (!1intch(2,0)  (.7) (.13)) -> !3builtin_comp2  (!1intch(2,0)  (.6) (.12)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.8) (.14))) in
-   let !1builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) {.5,.0 -> .1} (.6,.3 -> .5) => !1builtin_comp2  (.4) (.6) in 
+   let !1builtin_comp2 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) {.5,.0 -> .1} (.6,.3 -> .5) => !1builtin_comp2  (.4) (.6) in
    let !1UBPad.p(1) = Coh([[]], !1builtin_id  (.2) -> !1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)))) in
    let !1BPad.p(1) = Coh([[[]]], !1BPad.Padding(1)  (.2) (.3) (!1builtin_comp2  (.4) (!1builtin_id  (.3))) -> .4) in
-   let tm_8 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)  (.5) in 
-   let tm_4 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => .3 in 
+   let tm_8 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)  (.5) in
+   let tm_4 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => .3 in
    let !1UBPad.p(1) = Coh([[]], !1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) -> !1builtin_id  (.2)) in
-   let tm_2 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !1UBPad.p(1)  (.2) in 
+   let tm_2 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !1UBPad.p(1)  (.2) in
    let !1UBPad.p(1)_Unit = Coh([[]], !2builtin_comp2  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)))) (!1builtin_id  (.2)) (!1UBPad.p(1)  (.2)) (!1UBPad.p(1)  (.2)) -> !2builtin_id  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))))) in
    let !1BToURepad.g(1) = Coh([[]], !1BPad.p(1)  (!1builtin_id  (.2)) -> !2builtin_comp2  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) in
    let !1BToURepad.f(1)_op{1} = Coh([[]], !1!1builtin_comp2_op{1}  (!1BPad.p(1)_op{1}  (!1builtin_id  (.2))) (!1BToURepad.Repadding(1) ) -> !1UBPad.p(1)  (.2)) in
-   let tm_1 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !1UBPad.p(1)  (.2) in 
+   let tm_1 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !1UBPad.p(1)  (.2) in
    let !1BPad.p(1) = Coh([[[]]], .4 -> !1BPad.Padding(1)  (.2) (.3) (!1builtin_comp2  (.4) (!1builtin_id  (.3)))) in
-   let tm_7 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)  (.4) in 
+   let tm_7 = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !1BPad.p(1)  (.4) in
    let !1BToURepad.f(1) = Coh([[]], !2builtin_comp2  (!1BPad.p(1)  (!1builtin_id  (.2))) (!1BToURepad.Repadding(1) ) -> !1UBPad.p(1)  (.2)) in
    let !1BToURepad.g(1)_op{1} = Coh([[]], !1BPad.p(1)_op{1}  (!1builtin_id  (.2)) -> !1!1builtin_comp2_op{1}  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) in
    let builtin_id = Coh([], .0 -> .0) in
-   let ΣUToURepad.Repadding(2) = λ{.0,*} (.1,builtin_id  (.0) -> builtin_id  (.0)) => !2builtin_id  (.1) in 
-   let UBPad.Padding(2)_func[(.3,1)] = λ{.0,*} {.1,builtin_id  (.0) -> builtin_id  (.0)} {.2,builtin_id  (.0) -> builtin_id  (.0)} (.3,.1 -> .2) => .3 in 
-   let UBPad.Padding(2) = λ{.0,*} (.1,builtin_id  (.0) -> builtin_id  (.0)) => .1 in 
+   let ΣUToURepad.Repadding(2) = λ{.0,*} (.1,builtin_id  (.0) -> builtin_id  (.0)) => !2builtin_id  (.1) in
+   let UBPad.Padding(2)_func[(.3,1)] = λ{.0,*} {.1,builtin_id  (.0) -> builtin_id  (.0)} {.2,builtin_id  (.0) -> builtin_id  (.0)} (.3,.1 -> .2) => .3 in
+   let UBPad.Padding(2) = λ{.0,*} (.1,builtin_id  (.0) -> builtin_id  (.0)) => .1 in
    let UBPad.p(2) = Coh([], !1builtin_id  (builtin_id  (.0)) -> UBPad.Padding(2)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))))) in
    let ΣUToURepad.f(2) = Coh([], !2builtin_comp2  (!1UBPad.p(1)  (builtin_id  (.0))) (ΣUToURepad.Repadding(2) ) -> UBPad.p(2)  (.0)) in
    let UBPad.p(2) = Coh([], UBPad.Padding(2)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) -> !1builtin_id  (builtin_id  (.0))) in
    let ΣUToURepad.g(2) = Coh([], !1UBPad.p(1)  (builtin_id  (.0)) -> !2builtin_comp2  (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) in
    let !2builtin_comp3 = Coh([[[[][][]]]], .4 -> .9) in
    let !2builtin_comp3_func[(.8,1)] = Coh([[[[[]][][]]]], !2builtin_comp3  (.6) (.10) (.12) -> !2builtin_comp3  (.7) (.10) (.12)) in
-   let !1BPad.Padding(2) = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !2builtin_comp3  (!1BPad.p(1)  (.4)) (!1BPad.Padding(1)_func[(.6,1)]  (.2) (.3) (.6)) (!1BPad.p(1)  (.5)) in 
+   let !1BPad.Padding(2) = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.2 -> .3) (.5,.2 -> .3) (.6,!1builtin_comp2  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2  (.5) (!1builtin_id  (.3))) => !2builtin_comp3  (!1BPad.p(1)  (.4)) (!1BPad.Padding(1)_func[(.6,1)]  (.2) (.3) (.6)) (!1BPad.p(1)  (.5)) in
    let !1BPad.p(2) = Coh([[[[]]]], .6 -> !1BPad.Padding(2)  (.4) (.5) (!1builtin_comp2_func[(.6,1) (.10,1)]  (.6) (!2builtin_id  (!1builtin_id  (.3))))) in
    let !2intch_src = Coh([[[[][][]]]], !2builtin_comp3  (.6) (.8) (.10) -> !2builtin_comp3_red  (!2builtin_comp3  (.6) (.8) (.10))) in
    let !2_builtin_unitor = Coh([[[[][]]]], !2builtin_comp3  (.6) (!2builtin_id  (.5)) (.8) -> !2builtin_comp2  (.6) (.8)) in
-   let !1BPad.Padding(2)_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !2builtin_comp3  (!1BPad.p(1)_op{1}  (.4)) (!1BPad.Padding(1)_func[(.4,1)]_op{1}  (.2) (.3) (.6)) (!1BPad.p(1)_op{1}  (.5)) in 
+   let !1BPad.Padding(2)_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} (.4,.3 -> .2) (.5,.3 -> .2) (.6,!1builtin_comp2_op{1}  (.4) (!1builtin_id  (.3)) -> !1builtin_comp2_op{1}  (.5) (!1builtin_id  (.3))) => !2builtin_comp3  (!1BPad.p(1)_op{1}  (.4)) (!1BPad.Padding(1)_func[(.4,1)]_op{1}  (.2) (.3) (.6)) (!1BPad.p(1)_op{1}  (.5)) in
    let !1BPad.p(2)_op{1} = Coh([[[[]]]], .6 -> !1BPad.Padding(2)_op{1}  (.4) (.5) (!1builtin_comp2_func[(.4,1) (.8,1)]_op{1}  (.6) (!2builtin_id  (!1builtin_id  (.2))))) in
    let !2_builtin_assoc = Coh([[[[][][][][][]]]], !2builtin_comp2  (!2builtin_comp3  (.6) (.8) (.10)) (!2builtin_comp3  (.12) (.14) (.16)) -> !2builtin_comp3  (.6) (!2builtin_comp3  (.8) (!2builtin_comp2  (.10) (.12)) (.14)) (.16)) in
    let !2builtin_assc = Coh([[[[][][][]]]], !2builtin_comp3  (.6) (!2builtin_comp2  (.8) (.10)) (.12) -> !2builtin_comp3  (!2builtin_comp2  (.6) (.8)) (.10) (.12)) in
    let !2builtin_assc = Coh([[[[][][][]]]], !2builtin_comp3  (.6) (.8) (!2builtin_comp2  (.10) (.12)) -> !2builtin_comp3  (.6) (!2builtin_comp2  (.8) (.10)) (.12)) in
    let !2builtin_comp3_func[(.12,1)] = Coh([[[[][][[]]]]], !2builtin_comp3  (.6) (.8) (.10) -> !2builtin_comp3  (.6) (.8) (.11)) in
    let !2builtin_comp3_func[(.10,1)] = Coh([[[[][[]][]]]], !2builtin_comp3  (.6) (.8) (.12) -> !2builtin_comp3  (.6) (.9) (.12)) in
-   let UBPad.Padding(3)_func[(.3,1)] = λ{.0,*} {.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))} {.2,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))} (.3,.1 -> .2) => !2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (.3) (UBPad.p(2)  (.0)) in 
-   let !1UBPad.Padding(2)_func[(.5,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))} {.4,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))} (.5,.3 -> .4) => !2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (.5) (!1UBPad.p(1)  (.2)) in 
-   let !2builtin_comp3_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} {.8,.5 -> .7} {.9,.5 -> .7} (.10,.8 -> .9) {.11,.2 -> .3} (.12,.7 -> .11) => !2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12) in 
-   let tm_3 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) (.4,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2)) (!1UBPad.p(1)  (.2)) (tm_4  (.4)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)_Unit  (.2)) (tm_4  (.4))) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_4  (.4))) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!3builtin_id  (!2builtin_comp2  (.3) (.4))) (!1UBPad.p(1)  (.2))) in 
+   let UBPad.Padding(3)_func[(.3,1)] = λ{.0,*} {.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))} {.2,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))} (.3,.1 -> .2) => !2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (.3) (UBPad.p(2)  (.0)) in
+   let !1UBPad.Padding(2)_func[(.5,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))} {.4,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))} (.5,.3 -> .4) => !2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (.5) (!1UBPad.p(1)  (.2)) in
+   let !2builtin_comp3_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} (.6,.4 -> .5) {.7,.2 -> .3} {.8,.5 -> .7} {.9,.5 -> .7} (.10,.8 -> .9) {.11,.2 -> .3} (.12,.7 -> .11) => !2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12) in
+   let tm_3 = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) (.4,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2)) (!1UBPad.p(1)  (.2)) (tm_4  (.4)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)_Unit  (.2)) (tm_4  (.4))) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_4  (.4))) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (.2)) (!3builtin_id  (!2builtin_comp2  (.3) (.4))) (!1UBPad.p(1)  (.2))) in
    let intch_tgt^-1 = Coh([[[[][[][]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14)) -> !2builtin_comp3_func[(.10,1)]  (.6) (!3builtin_comp2  (.10) (.12)) (.14)) in
    let !2intch_src^-1_func[(.10,1)] = Coh([[[[][[]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)) (!2intch_src  (.6) (.9) (.12)) -> !3builtin_comp2  (!2intch_src  (.6) (.8) (.12)) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)))) in
    let !1BPad.p(2)^-1_func[(.8,1)] = Coh([[[[[]]]]], !3builtin_comp2  (.8) (!1BPad.p(2)  (.7)) -> !3builtin_comp2  (!1BPad.p(2)  (.6)) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)  (.4)) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.8) (!2builtin_id  (!1builtin_id  (.3)))) (!1BPad.p(1)  (.5)))) in
    let !1BPad.p(2)_op{1}^-1_func[(.8,1)] = Coh([[[[[]]]]], !3builtin_comp2  (.8) (!1BPad.p(2)_op{1}  (.7)) -> !3builtin_comp2  (!1BPad.p(2)_op{1}  (.6)) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)_op{1}  (.4)) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (.2))) (.8)) (!1BPad.p(1)_op{1}  (.5)))) in
    let !2builtin_assc^-1_func[(.12,1)] = Coh([[[[][][[]][]]]], !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (!2builtin_comp2_func[(.10,1)]  (.8) (.12)) (.14)) (!2builtin_assc  (.6) (.8) (.11) (.14)) -> !3builtin_comp2  (!2builtin_assc  (.6) (.8) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (.6) (.8)) (.12) (.14))) in
    let !2builtin_comp3_func[(.8,1) (.14,1)] = Coh([[[[[]][][[]]]]], !2builtin_comp3  (.6) (.10) (.12) -> !2builtin_comp3  (.7) (.10) (.13)) in
-   let !2builtin_comp3_func[(.8,1) (.14,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} (.10,.5 -> .9) {.11,.2 -> .3} {.12,.9 -> .11} {.13,.9 -> .11} (.14,.12 -> .13) => !2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.10) (.14) in 
+   let !2builtin_comp3_func[(.8,1) (.14,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} (.8,.6 -> .7) {.9,.2 -> .3} (.10,.5 -> .9) {.11,.2 -> .3} {.12,.9 -> .11} {.13,.9 -> .11} (.14,.12 -> .13) => !2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.10) (.14) in
    let !2_builtin_assoc^-1_func[(.10,1) (.18,1)] = Coh([[[[][[]][][][[]][]]]], !3builtin_comp2  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12)) (!2builtin_comp3_func[(.10,1)]  (.14) (.18) (.20))) (!2_builtin_assoc  (.6) (.9) (.12) (.14) (.17) (.20)) -> !3builtin_comp2  (!2_builtin_assoc  (.6) (.8) (.12) (.14) (.16) (.20)) (!2builtin_comp3_func[(.10,1)]  (.6) (!2builtin_comp3_func[(.8,1) (.14,1)]  (.10) (!2builtin_comp2  (.12) (.14)) (.18)) (.20))) in
    let !2_builtin_unitor^-1_func[(.8,1) (.12,1)] = Coh([[[[[]][[]]]]], !3builtin_comp2  (!2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (!2builtin_id  (.5)) (.12)) (!2_builtin_unitor  (.7) (.11)) -> !3builtin_comp2  (!2_builtin_unitor  (.6) (.10)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (.8) (.12))) in
    let !2builtin_comp3^-1_func[(.12,1)][(.8,1) (.16,1)] = Coh([[[[[]][[]][[]]]]], !3builtin_comp2  (!2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.10) (.16)) (!2builtin_comp3_func[(.10,1)]  (.7) (.12) (.15)) -> !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14)) (!2builtin_comp3_func[(.8,1) (.14,1)]  (.8) (.11) (.16))) in
@@ -917,20 +919,20 @@
    let !2intch_tgt^-1_func[(.10,1)] = Coh([[[[][[]][]]]], !3builtin_comp2  (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12))) (!2intch_tgt  (.6) (.9) (.12)) -> !3builtin_comp2  (!2intch_tgt  (.6) (.8) (.12)) (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.12))) in
    let intch_src^-1 = Coh([[[[][[][]][]]]], !2builtin_comp3_func[(.10,1)]  (.6) (!3builtin_comp2  (.10) (.12)) (.14) -> !3builtin_comp2  (!2builtin_comp3_func[(.10,1)]  (.6) (.10) (.14)) (!2builtin_comp3_func[(.10,1)]  (.6) (.12) (.14))) in
    let !2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5} = Coh([[[[][[[]]][]]]], !2builtin_comp3_func[(.10,1)]  (.6) (.10) (.14) -> !2builtin_comp3_func[(.10,1)]  (.6) (.11) (.14)) in
-   let UBPad.Padding(3) = λ{.0,*} (.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) => !2builtin_comp3  (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0)) in 
+   let UBPad.Padding(3) = λ{.0,*} (.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) => !2builtin_comp3  (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0)) in
    let UBPad.p(3) = Coh([], !2builtin_comp2  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) -> UBPad.Padding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) in
    let UBPad.p(3) = Coh([], UBPad.Padding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) -> !2builtin_comp2  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) in
    let !3builtin_comp3 = Coh([[[[[][][]]]]], .6 -> .11) in
-   let !1BToURepad.Repadding(2) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp3  (!2intch_src  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_8  (.3))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.g(1)  (.2))) (!2builtin_assc  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (.3)) (!2builtin_id^-1_func[(.6,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_assc  (tm_7  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))))) (!2intch_tgt  (!1builtin_id  (.2)) (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) in 
+   let !1BToURepad.Repadding(2) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp3  (!2intch_src  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_8  (.3))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.g(1)  (.2))) (!2builtin_assc  (tm_7  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (.3)) (!2builtin_id^-1_func[(.6,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_assc  (tm_7  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))))) (!2intch_tgt  (!1builtin_id  (.2)) (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) in
    let intch_tgt^-1 = Coh([[[[[][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp3  (.10) (.12) (.14)) -> !3builtin_comp5_red  (!3builtin_comp2  (.8) (!3builtin_comp3  (.10) (.12) (.14)))) in
    let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp2  (.8) (!3builtin_comp3  (.10) (.12) (.14)) -> !3builtin_comp3  (!3builtin_comp2  (.8) (.10)) (.12) (.14)) in
-   let !1BToURepad.Repadding(2)_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2_op{1}  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2_op{1}  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp3  (!2intch_src  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_6  (.3))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.g(1)_op{1}  (.2))) (!2builtin_assc  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (.3)) (!2builtin_id^-1_func[(.6,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_assc  (tm_5  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))))) (!2intch_tgt  (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) in 
-   let !1eh^2_(1,0) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_id  (.2) -> !1builtin_id  (.2)) (.4,!1builtin_id  (.2) -> !1builtin_id  (.2)) => !3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (.3)) (!1BPad.p(2)_op{1}  (.4))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.3) (!2builtin_id  (!1builtin_id  (.2))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (.2))) (.4)))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.3) (!2builtin_id  (!1builtin_id  (.2)))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (.2))) (.4))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (.3) (.4))) in 
+   let !1BToURepad.Repadding(2)_op{1} = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_comp2_op{1}  (!1builtin_id  (.2)) (!1builtin_id  (.2)) -> !1builtin_comp2_op{1}  (!1builtin_id  (.2)) (!1builtin_id  (.2))) => !3builtin_comp3  (!2intch_src  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (tm_6  (.3))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.g(1)_op{1}  (.2))) (!2builtin_assc  (tm_5  (.3)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (.3)) (!2builtin_id^-1_func[(.6,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_assc  (tm_5  (.3)) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))))) (!2intch_tgt  (!1UBPad.p(1)  (.2)) (!1UBPad.Padding(1)_func[(.5,1)]  (.3)) (!1UBPad.p(1)  (.2))) in
+   let !1eh^2_(1,0) = λ{.0,*} {.1,*} {.2,.0 -> .1} (.3,!1builtin_id  (.2) -> !1builtin_id  (.2)) (.4,!1builtin_id  (.2) -> !1builtin_id  (.2)) => !3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (.3)) (!1BPad.p(2)_op{1}  (.4))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.3) (!2builtin_id  (!1builtin_id  (.2))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (.2))) (.4)))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.3) (!2builtin_id  (!1builtin_id  (.2)))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (.2))) (.4))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (.3) (.4))) in
    let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp3  (!3builtin_comp2  (.8) (.10)) (.12) (.14) -> !3builtin_comp3  (.8) (!3builtin_comp2  (.10) (.12)) (.14)) in
    let !3builtin_comp3_func[(.12,1)] = Coh([[[[[][[]][]]]]], !3builtin_comp3  (.8) (.10) (.14) -> !3builtin_comp3  (.8) (.11) (.14)) in
    let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp3  (.8) (!3builtin_comp2  (.10) (.12)) (.14) -> !3builtin_comp3  (.8) (.10) (!3builtin_comp2  (.12) (.14))) in
-   let ΣUToURepad.Repadding(3) = λ{.0,*} (.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) => !3builtin_comp3  (!2intch_src  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (tm_2  (.1))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (.1)) (!2builtin_id^-1_func[(.6,1)]  (.1)) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (.1)) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))) in 
-   let eh^3_(2,1) = λ{.0,*} (.1,!1builtin_id  (builtin_id  (.0)) -> !1builtin_id  (builtin_id  (.0))) (.2,!1builtin_id  (builtin_id  (.0)) -> !1builtin_id  (builtin_id  (.0))) => !3builtin_comp2  (!1eh^2_(1,0)  (.1) (.2)) (ΣUToURepad.Repadding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.1) (.2))) in 
+   let ΣUToURepad.Repadding(3) = λ{.0,*} (.1,!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))) -> !1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))) => !3builtin_comp3  (!2intch_src  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (tm_2  (.1))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (.1)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (.1)) (!2builtin_id^-1_func[(.6,1)]  (.1)) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (.1)) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (.1)) (UBPad.p(2)  (.0))) in
+   let eh^3_(2,1) = λ{.0,*} (.1,!1builtin_id  (builtin_id  (.0)) -> !1builtin_id  (builtin_id  (.0))) (.2,!1builtin_id  (builtin_id  (.0)) -> !1builtin_id  (builtin_id  (.0))) => !3builtin_comp2  (!1eh^2_(1,0)  (.1) (.2)) (ΣUToURepad.Repadding(3)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (.1) (.2))) in
    let _eh_to_p(3,2,1) = Coh([], eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) -> UBPad.p(3)  (.0)) in
    let !3_unbiasor_left = Coh([[[[[][][]]]]], !3builtin_comp2  (!3builtin_comp2  (.8) (.10)) (.12) -> !3builtin_comp3  (.8) (.10) (.12)) in
    let !3builtin_assc^-1 = Coh([[[[[][][][]]]]], !3builtin_comp3  (.8) (.10) (!3builtin_comp2  (.12) (.14)) -> !3builtin_comp2  (!3builtin_comp3  (.8) (.10) (.12)) (.14)) in
@@ -938,6 +940,6 @@
    let _factor_id(3,2,1) = Coh([], !3builtin_id  (!2builtin_comp2  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) -> !3builtin_comp2  (eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (UBPad.p(3)  (.0))) in
    let intch_src^-1 = Coh([[[[[][][][]]]]], !3builtin_comp5_red  (!3builtin_comp2  (!3builtin_comp3  (.8) (.10) (.12)) (.14)) -> !3builtin_comp2  (!3builtin_comp3  (.8) (.10) (.12)) (.14)) in
    let !3builtin_comp3_func[(.10,1)] = Coh([[[[[[]][][]]]]], !3builtin_comp3  (.8) (.12) (.14) -> !3builtin_comp3  (.9) (.12) (.14)) in
-   let !3builtin_comp3_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} {.8,.6 -> .7} {.9,.6 -> .7} (.10,.8 -> .9) {.11,.4 -> .5} (.12,.7 -> .11) {.13,.4 -> .5} (.14,.11 -> .13) => !3builtin_comp3_func[(.10,1)]  (.10) (.12) (.14) in 
+   let !3builtin_comp3_func[(.10,1)] = λ{.0,*} {.1,*} {.2,.0 -> .1} {.3,.0 -> .1} {.4,.2 -> .3} {.5,.2 -> .3} {.6,.4 -> .5} {.7,.4 -> .5} {.8,.6 -> .7} {.9,.6 -> .7} (.10,.8 -> .9) {.11,.4 -> .5} (.12,.7 -> .11) {.13,.4 -> .5} (.14,.11 -> .13) => !3builtin_comp3_func[(.10,1)]  (.10) (.12) (.14) in
    let !4builtin_comp6 = Coh([[[[[[][][][][][]]]]]], .8 -> .19) in
    !4builtin_comp6  (!3_ehnat_step1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2))) (!3builtin_comp2_func[(.12,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (_factor_id(3,2,1)  (.0))) (!3assoc  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (UBPad.p(3)  (.0))) (!3builtin_comp2_func[(.10,1)]  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp5  (!3assoc  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_comp2_func[(.10,1)]  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp9  (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (.1) (.2)) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.10,1)]  (!4builtin_comp3  (intch_tgt^-1  (.1) (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (.2) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]_red_func[(.10,1) (.16,1)]_op{5}  (!1BPad.p(2)^-1_func[(.8,1)]  (.1)) (!1BPad.p(2)_op{1}^-1_func[(.8,1)]  (.2))) (intch_src^-1  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(1)  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BPad.p(1)_op{1}  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.12,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]_red_func[(.10,1) (.16,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp7  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.10,1)]  (!2intch_src^-1_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.12,1)]  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp11  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.10,1)]  (!2builtin_comp3^-1_func[(.14,1)][(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp2  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.12,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.Repadding(1) )) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.14,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BToURepad.Repadding(1) )) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1^-1_func[(.8,2)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.16,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) )) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.18,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3^-1_func[(.8,1)][(.12,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.14,1)]  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt^-1_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp7  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.10,1)]  (!2intch_src^-1_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.12,1)]  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp11  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.10,1)]  (!2builtin_comp3^-1_func[(.14,1)][(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!2builtin_comp2  (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.12,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.Repadding(1) )) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.14,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1BToURepad.Repadding(1) )) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1^-1_func[(.8,2)]  (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.16,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc^-1_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) )) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_func[(.18,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3^-1_func[(.8,1)][(.12,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp3_func[(.14,1)]  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt^-1_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!3builtin_comp3  (!2intch_src  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_8  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_7  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!3builtin_comp3  (!2intch_src  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_6  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.g(1)_op{1}  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_assc  (tm_5  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(1) ) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.8,1)]  (!1BToURepad.f(1)_op{1}  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2intch_tgt  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.14,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp9  (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.10,1)]  (!2_builtin_assoc^-1_func[(.10,1) (.18,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp2  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.12,1)]  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_comp2  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3^-1_func[(.12,1)][(.8,1) (.16,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_id  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_id  (!1UBPad.Padding(1)  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.14,1)]  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.8,1) (.14,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!2builtin_id  (!1builtin_comp2  (!1builtin_id  (builtin_id  (.0))) (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor^-1_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.16,1)]  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id^-1_func[(.8,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2)))) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_assc^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!3builtin_comp4_func[(.16,1)]  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!4builtin_comp3  (intch_tgt^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1builtin_comp2_func[(.8,2) (.12,1)]  (.1) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.12,2)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (.2))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)^-1_func[(.8,1) (.14,1)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (intch_src^-1  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_assc^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0))))))) (intch_src^-1  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp4  (!2_builtin_assoc  (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0))) (!1UBPad.p(1)  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.p(1)_Unit  (builtin_id  (.0))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!2_builtin_unitor  (!1UBPad.Padding(1)_func[(.5,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_4  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!3builtin_id  (!2builtin_comp2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!1UBPad.p(1)  (builtin_id  (.0))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1UBPad.p(1)  (builtin_id  (.0)))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_assc  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.10,1)]  (!1UBPad.p(1)  (builtin_id  (.0))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!1UBPad.p(1)  (builtin_id  (.0)))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!3builtin_comp2_func[(.12,1)]  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp7  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp3_func[(.10,1)]  (!2intch_src^-1_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp3_func[(.12,1)]  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2builtin_comp3_red_func[(.8,1)]_red_func[(.10,1)]_op{5}  (!4builtin_comp3  (intch_tgt^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_red_func[(.10,1)]_op{5}  (!4builtin_comp11  (!3builtin_assc^-1  (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.10,1)]  (!2builtin_comp3^-1_func[(.14,1)][(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (!2builtin_comp2  (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0)))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.12,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc^-1_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.Repadding(2) )) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.14,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!4builtin_comp3  (intch_tgt^-1  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (ΣUToURepad.Repadding(2) )) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]_red_func[(.12,1)]_op{5}  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1^-1_func[(.8,2)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(2)  (.0))) (intch_src^-1  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (ΣUToURepad.Repadding(2) ) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(2)  (.0)))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.10,1)]  (ΣUToURepad.Repadding(2) ) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.16,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc^-1_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (!2builtin_comp2  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) )) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp5_func[(.18,1)]  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3^-1_func[(.8,1)][(.12,1)]  (ΣUToURepad.f(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2builtin_comp3_red_func[(.8,1)]  (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!3builtin_comp3_func[(.14,1)]  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt^-1_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))) (!3builtin_assc^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (!3assoc  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0)))))) (intch_src^-1  (!3builtin_comp4  (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BPad.p(2)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1BPad.p(2)_op{1}  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_comp2_func[(.8,1) (.12,1)]  (!1BToURepad.Repadding(2)  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1BToURepad.Repadding(2)_op{1}  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (tm_3  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!1UBPad.Padding(2)_func[(.5,1)]  (!1intch(2,0)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!3builtin_comp3  (!2intch_src  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (tm_2  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))))) (!2builtin_comp3_red_func[(.8,1)]  (!3builtin_comp5  (!2builtin_comp3_func[(.12,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.g(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.10,1)]  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (!2builtin_id^-1_func[(.6,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_assc  (tm_1  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (ΣUToURepad.Repadding(2) ) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))) (!2builtin_comp3_func[(.8,1)]  (ΣUToURepad.f(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0))))) (!2intch_tgt  (!1builtin_id  (builtin_id  (.0))) (UBPad.p(2)  (.0)) (UBPad.Padding(2)_func[(.3,1)]  (!1builtin_comp2_func[(.6,1) (.10,1)]  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))))) (UBPad.p(2)  (.0)))) (!2builtin_comp3_func[(.10,1)]  (UBPad.p(2)  (.0)) (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2)) (UBPad.p(2)  (.0))))) (UBPad.p(3)  (.0))) (!3_unbiasor_left  (eh^3_(2,1)  (!2builtin_id  (!1builtin_id  (builtin_id  (.0)))) (!2builtin_id  (!1builtin_id  (builtin_id  (.0))))) (UBPad.Padding(3)_func[(.3,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(3)  (.0))) (!3builtin_comp3_func[(.10,1)]  (_eh_to_p(3,2,1)  (.0)) (UBPad.Padding(3)_func[(.3,1)]  (!1builtin_comp2_func[(.8,2) (.14,2)]  (.1) (.2))) (UBPad.p(3)  (.0))).

From c4d74b2a6c0f23d5b2bcf14432ae35722baca070 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Thu, 30 Oct 2025 11:20:04 +0100
Subject: [PATCH 24/30] prepare for adding 2 levels (temporarily disable
 kolmogorov printing)

---
 lib/dune                          |   2 +-
 lib/internals/core.mli            |  17 +-
 lib/internals/kernel.ml           |  19 +-
 lib/internals/kernel.mli          |   2 +
 lib/internals/kernelSignature.mli |  92 ++++++++
 lib/internals/printing.ml         | 375 +++++++++++++++---------------
 lib/internals/unchecked.ml        |   6 +-
 lib/internals/unchecked.mli       |   2 +-
 lib/lib/common.ml                 |   2 +
 lib/lib/common.mli                |   2 +
 10 files changed, 317 insertions(+), 202 deletions(-)
 create mode 100644 lib/internals/kernelSignature.mli

diff --git a/lib/dune b/lib/dune
index b65089de..96e7c69b 100644
--- a/lib/dune
+++ b/lib/dune
@@ -3,7 +3,7 @@
 (library
  (name catt)
  (public_name catt)
- (modules_without_implementation raw_types core)
+ (modules_without_implementation raw_types core kernelSignature)
  (libraries base)
  (instrumentation
   (backend landmarks --auto)))
diff --git a/lib/internals/core.mli b/lib/internals/core.mli
index ae5948ec..546606b2 100644
--- a/lib/internals/core.mli
+++ b/lib/internals/core.mli
@@ -1,17 +1,24 @@
 open Common
 
 module type S = sig
-  module rec Coh : sig
+  module InnerTm : sig
     type t
+  end
+
+  module Coh : sig
+    type t
+
+    val suspend : t -> t
 
-    val forget : t -> ps * (t, Tm.t) ty * pp_data
-    val check : ps -> (t, Tm.t) ty -> pp_data -> t
+    (* val collect_decls : t -> (t, InnerTm.t) decls -> (t, InnerTm.t) decls *)
+    (* val to_string_kolmogorov : t -> (t, InnerTm.t) decls -> string *)
+    val forget : t -> ps * (t, InnerTm.t) ty * pp_data
     val to_string : ?unroll:bool -> t -> string
     val func_data : t -> (Var.t * int) list list
     val is_equal : t -> t -> bool
   end
 
-  and Tm : sig
+  module Tm : sig
     type t
 
     val develop : t -> (Coh.t, t) tm
@@ -22,7 +29,7 @@ module type S = sig
     val is_equal : t -> t -> bool
 
     val apply :
-      ((Coh.t, Tm.t) ctx -> (Coh.t, t) ctx) ->
+      ((Coh.t, t) ctx -> (Coh.t, t) ctx) ->
       ((Coh.t, t) tm -> (Coh.t, t) tm) ->
       (pp_data -> pp_data) ->
       t ->
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index 798f01aa..f05821c9 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -29,6 +29,7 @@ module Make (Theory : Theory.S) = struct
     let tgt s = s.tgt
 
     module Core = struct
+      module InnerTm = Tm
       module Coh = Coh
       module Tm = Tm
     end
@@ -101,6 +102,7 @@ module Make (Theory : Theory.S) = struct
     type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
 
     module Core = struct
+      module InnerTm = Tm
       module Coh = Coh
       module Tm = Tm
     end
@@ -180,6 +182,7 @@ module Make (Theory : Theory.S) = struct
     exception Invalid
 
     module Core = struct
+      module InnerTm = Tm
       module Coh = Coh
       module Tm = Tm
     end
@@ -341,6 +344,7 @@ module Make (Theory : Theory.S) = struct
     val dim : t -> int
   end = struct
     module Core = struct
+      module InnerTm = Tm
       module Coh = Coh
       module Tm = Tm
     end
@@ -471,6 +475,7 @@ module Make (Theory : Theory.S) = struct
     val is_equal : t -> t -> bool
   end = struct
     module Core = struct
+      module InnerTm = Tm
       module Coh = Coh
       module Tm = Tm
     end
@@ -622,6 +627,7 @@ module Make (Theory : Theory.S) = struct
     val ty : t -> Ty.t
     val src : t -> (t, Tm.t) tm
     val tgt : t -> (t, Tm.t) tm
+    val suspend : t -> t
     val check : ps -> (t, Tm.t) ty -> pp_data -> t
     val check_noninv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
     val check_inv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
@@ -653,6 +659,7 @@ module Make (Theory : Theory.S) = struct
     type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
 
     module Core = struct
+      module InnerTm = Tm
       module Coh = Coh
       module Tm = Tm
     end
@@ -758,9 +765,9 @@ module Make (Theory : Theory.S) = struct
 
     let to_string ?(unroll = false) c =
       let ps, ty, pp_data = data c in
-      if not (unroll || !Settings.unroll_coherences) then
-        Printing.pp_data_to_string pp_data
-      else Printf.sprintf "Coh(%s,%s)" (PS.to_string ps) (Ty.to_string ty)
+      if unroll || !Settings.unroll_coherences then
+        Printf.sprintf "Coh(%s,%s)" (PS.to_string ps) (Ty.to_string ty)
+      else Printing.pp_data_to_string pp_data
 
     let noninv_srctgt c =
       match c with
@@ -791,6 +798,11 @@ module Make (Theory : Theory.S) = struct
           PS.is_equal d1.ps d2.ps && Ty.is_equal d1.total_ty d2.total_ty
       | Inv _, NonInv _ | NonInv _, Inv _ -> false
 
+    let suspend coh =
+      let ps, ty, pp_data = forget coh in
+      check (Unchecked.suspend_ps ps) (Unchecked.suspend_ty ty)
+        (Unchecked.suspend_pp_data pp_data)
+
     let check_equal coh1 coh2 =
       if not (is_equal coh1 coh2) then
         raise (NotEqual (to_string coh1, to_string coh2))
@@ -813,6 +825,7 @@ module Make (Theory : Theory.S) = struct
   end
 
   module Core = struct
+    module InnerTm = Tm
     module Coh = Coh
     module Tm = Tm
   end
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index aee6cbc2..d18d56f5 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -5,6 +5,7 @@ module Make (_ : Theory.S) : sig
     type t
 
     val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
+    val suspend : t -> t
     val is_equal : t -> t -> bool
     val check_equal : t -> t -> unit
     val is_inv : t -> bool
@@ -72,6 +73,7 @@ module Make (_ : Theory.S) : sig
   end
 
   module Core : sig
+    module InnerTm = Tm
     module Coh = Coh
     module Tm = Tm
   end
diff --git a/lib/internals/kernelSignature.mli b/lib/internals/kernelSignature.mli
new file mode 100644
index 00000000..bf5df700
--- /dev/null
+++ b/lib/internals/kernelSignature.mli
@@ -0,0 +1,92 @@
+open Common
+
+module type S = sig
+  module rec Coh : sig
+    type t
+
+    val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val is_inv : t -> bool
+    val to_string : ?unroll:bool -> t -> string
+    val dim : t -> int
+    val src : t -> (Coh.t, Tm.t) tm
+    val tgt : t -> (Coh.t, Tm.t) tm
+    val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
+
+    val check_noninv :
+      ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
+
+    val check_inv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
+
+    val noninv_srctgt :
+      t -> (Coh.t, Tm.t) tm * (Coh.t, Tm.t) tm * (Coh.t, Tm.t) ty
+
+    val func_data : t -> (Var.t * int) list list
+
+    val apply_ps :
+      (ps -> ps) ->
+      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) sub
+  end
+
+  and Ty : sig
+    type t
+
+    val forget : t -> (Coh.t, Tm.t) ty
+    val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
+  end
+
+  and Tm : sig
+    type t
+
+    val typ : t -> Ty.t
+    val ty : t -> (Coh.t, Tm.t) ty
+    val forget : t -> (Coh.t, Tm.t) tm
+    val constr : t -> (Coh.t, Tm.t) constr
+    val bdry : t -> t * t
+    val ctx : t -> (Coh.t, Tm.t) ctx
+    val name : t -> string option
+    val full_name : t -> string option
+    val func_data : t -> (Var.t * int) list list option
+    val of_coh : Coh.t -> t
+    val develop : t -> (Coh.t, Tm.t) tm
+    val pp_data : t -> pp_data option
+    val to_string : t -> string
+    val is_equal : t -> t -> bool
+
+    val apply :
+      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
+      ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) sub
+  end
+
+  and Ctx : sig
+    type t
+
+    val check : (Coh.t, Tm.t) ctx -> t
+  end
+
+  module Core : Core.S
+  include module type of Syntax.Make (Core)
+
+  module PS : sig
+    exception Invalid
+
+    type t
+
+    val mk : Ctx.t -> t
+    val forget : t -> ps
+  end
+end
diff --git a/lib/internals/printing.ml b/lib/internals/printing.ml
index b1bb7038..e6357e85 100644
--- a/lib/internals/printing.ml
+++ b/lib/internals/printing.ml
@@ -170,192 +170,190 @@ module Make (Core : Core.S) = struct
     let full_name name = pp_data_to_string ~print_func:true name
   end
 
-  module Kolmogorov = struct
-    type value = Tm of Tm.t | Coh of Coh.t
-
-    let counter = ref 0
-
-    let new_name () =
-      incr counter;
-      Printf.sprintf "tm_%i" !counter
-
-    let find t decls =
-      let rec find t decls =
-        match (t, decls) with
-        | _, [] -> None
-        | Tm t, (Tm u, n) :: _ when Tm.is_equal t u -> Some n
-        | Coh c1, (Coh c2, n) :: _ when Coh.is_equal c1 c2 -> Some n
-        | _, _ :: decls -> find t decls
-      in
-      find t decls
-
-    let rec collect_decls_ty decls = function
-      | Meta_ty _ -> assert false
-      | Obj -> decls
-      | Arr (_, u, v) ->
-          let decls = collect_decls_tm decls u in
-          collect_decls_tm decls v
-
-    and collect_decls_tm decls = function
-      | Var _ -> decls
-      | Meta_tm _ -> assert false
-      | Coh (c, s) ->
-          let decls =
-            match find (Coh c) decls with
-            | Some _ -> decls
-            | None ->
-                let _, _, pp_data = Coh.forget c in
-                let name = Regular.full_name pp_data in
-                let decls = (Coh c, name) :: decls in
-                collect_decls_coh decls c
-          in
-          collect_decls_sub_ps decls s
-      | App (t, s) ->
-          let decls =
-            match find (Tm t) decls with
-            | Some _ -> decls
-            | None ->
-                let name =
-                  match Tm.full_name t with
-                  | Some name -> name
-                  | None -> new_name ()
-                in
-                let decls = (Tm t, name) :: decls in
-                collect_decls_checkedtm decls t
-          in
-          collect_decls_sub decls s
-
-    and collect_decls_checkedtm decls t =
-      let decls = collect_decls_tm decls (Tm.develop t) in
-      collect_decls_ctx decls (Tm.ctx t)
-
-    and collect_decls_coh decls c =
-      let _, ty, _ = Coh.forget c in
-      collect_decls_ty decls ty
-
-    and collect_decls_sub_ps decls = function
-      | [] -> decls
-      | (t, expl) :: s ->
-          if expl then
-            let decls = collect_decls_tm decls t in
-            collect_decls_sub_ps decls s
-          else collect_decls_sub_ps decls s
-
-    and collect_decls_sub decls s = collect_decls_sub_ps decls (List.map snd s)
-
-    and collect_decls_ctx decls = function
-      | [] -> decls
-      | (_, (ty, _)) :: ctx -> collect_decls_ctx (collect_decls_ty decls ty) ctx
-
-    let order_decls decls =
-      let all_deps_done t ordered =
-        let deps =
-          match t with
-          | Tm t -> collect_decls_checkedtm [] t
-          | Coh c -> collect_decls_coh [] c
-        in
-        List.for_all
-          (fun (m, _) ->
-            List.exists
-              (fun (n, _) ->
-                match (n, m) with
-                | Tm t1, Tm t2 -> Tm.is_equal t1 t2
-                | Coh c1, Coh c2 -> Coh.is_equal c1 c2
-                | _, _ -> false)
-              ordered)
-          deps
-      in
-      let rec add_next decls ordered front =
-        match decls with
-        | [] -> assert false
-        | (t, n) :: decls when all_deps_done t ordered ->
-            (List.append front decls, (t, n) :: ordered)
-        | (t, n) :: decls -> add_next decls ordered ((t, n) :: front)
-      in
-      let rec add_recursively decls ordered =
-        match decls with
-        | [] -> ordered
-        | _ ->
-            let decls, ordered = add_next decls ordered [] in
-            add_recursively decls ordered
-      in
-      add_recursively decls []
-
-    let rec ty_to_string decls = function
-      | Meta_ty _ -> assert false
-      | Obj -> "*"
-      | Arr (_, u, v) ->
-          let u = tm_to_string decls u in
-          let v = tm_to_string decls v in
-          Printf.sprintf "%s -> %s" u v
-
-    and tm_to_string decls t =
-      match t with
-      | Var v -> Var.to_string v
-      | Meta_tm _ -> assert false
-      | Coh (c, s) ->
-          let c =
-            match find (Coh c) decls with Some c -> c | None -> assert false
-          in
-          let s = sub_ps_to_string decls s in
-          Printf.sprintf "%s %s" c s
-      | App (t, s) ->
-          let t =
-            match find (Tm t) decls with Some t -> t | None -> assert false
-          in
-          let s = sub_to_string decls s in
-          Printf.sprintf "%s %s" t s
-
-    and sub_ps_to_string decls s =
-      match s with
-      | [] -> ""
-      | (t, expl) :: s ->
-          if expl then
-            let t = tm_to_string decls t in
-            let s = sub_ps_to_string decls s in
-            Printf.sprintf "%s (%s)" s t
-          else sub_ps_to_string decls s
-
-    and sub_to_string decls s = sub_ps_to_string decls (List.map snd s)
-
-    let print_tm_in_ctx decls ctx tm =
-      let rec print decls ctx res =
-        match ctx with
-        | [] -> "λ" ^ res
-        | (x, (ty, true)) :: ctx ->
-            let ty = ty_to_string decls ty in
-            let res = Printf.sprintf "(%s,%s) %s" (Var.to_string x) ty res in
-            print decls ctx res
-        | (x, (ty, false)) :: ctx ->
-            let ty = ty_to_string decls ty in
-            let res = Printf.sprintf "{%s,%s} %s" (Var.to_string x) ty res in
-            print decls ctx res
-      in
-      print decls ctx (Printf.sprintf "=> %s" tm)
-
-    let print_tm t =
-      let rec print_decls decls res =
-        match decls with
-        | [] -> res
-        | (Tm t, name) :: decls ->
-            let ctx = Tm.ctx t in
-            let newtm = tm_to_string decls (Tm.develop t) in
-            let newdecl = print_tm_in_ctx decls ctx newtm in
-            let res = Printf.sprintf "let %s = %s in \n %s" name newdecl res in
-            print_decls decls res
-        | (Coh c, name) :: decls ->
-            let ps, ty, _ = Coh.forget c in
-            let res =
-              Printf.sprintf "let %s = Coh(%s, %s) in\n %s" name
-                (Regular.ps_to_string ps) (ty_to_string decls ty) res
-            in
-            print_decls decls res
-      in
-      let decls = collect_decls_tm [] t in
-      let decls = order_decls decls in
-      let res = tm_to_string decls t in
-      print_decls decls res
-  end
+  (* module Kolmogorov = struct *)
+  (*   let counter = ref 0 *)
+
+  (*   let new_name () = *)
+  (*     incr counter; *)
+  (*     Printf.sprintf "tm_%i" !counter *)
+
+  (*   let find t decls = *)
+  (*     let rec find t decls = *)
+  (*       match (t, decls) with *)
+  (*       | _, [] -> None *)
+  (*       | VTm t, (VTm u, n) :: _ when Tm.is_equal t u -> Some n *)
+  (*       | VCoh c1, (VCoh c2, n) :: _ when Coh.is_equal c1 c2 -> Some n *)
+  (*       | _, _ :: decls -> find t decls *)
+  (*     in *)
+  (*     find t decls *)
+
+  (*   let rec collect_decls_ty decls = function *)
+  (*     | Meta_ty _ -> assert false *)
+  (*     | Obj -> decls *)
+  (*     | Arr (_, u, v) -> *)
+  (*         let decls = collect_decls_tm decls u in *)
+  (*         collect_decls_tm decls v *)
+
+  (*   and collect_decls_tm decls = function *)
+  (*     | Var _ -> decls *)
+  (*     | Meta_tm _ -> assert false *)
+  (*     | Coh (c, s) -> *)
+  (*         let decls = *)
+  (*           match find (VCoh c) decls with *)
+  (*           | Some _ -> decls *)
+  (*           | None -> *)
+  (*               let _, _, pp_data = Coh.forget c in *)
+  (*               let name = Regular.full_name pp_data in *)
+  (*               let decls = (VCoh c, name) :: decls in *)
+  (*               collect_decls_coh decls c *)
+  (*         in *)
+  (*         collect_decls_sub_ps decls s *)
+  (*     | App (t, s) -> *)
+  (*         let decls = *)
+  (*           match find (VTm t) decls with *)
+  (*           | Some _ -> decls *)
+  (*           | None -> *)
+  (*               let name = *)
+  (*                 match Tm.full_name t with *)
+  (*                 | Some name -> name *)
+  (*                 | None -> new_name () *)
+  (*               in *)
+  (*               let decls = (VTm t, name) :: decls in *)
+  (*               collect_decls_checkedtm decls t *)
+  (*         in *)
+  (*         collect_decls_sub decls s *)
+
+  (*   and collect_decls_checkedtm decls t = *)
+  (*     let decls = collect_decls_tm decls (Tm.develop t) in *)
+  (*     collect_decls_ctx decls (Tm.ctx t) *)
+
+  (*   and collect_decls_coh decls c = *)
+  (*     let _, ty, _ = Coh.forget c in *)
+  (*     collect_decls_ty decls ty *)
+
+  (*   and collect_decls_sub_ps decls = function *)
+  (*     | [] -> decls *)
+  (*     | (t, expl) :: s -> *)
+  (*         if expl then *)
+  (*           let decls = collect_decls_tm decls t in *)
+  (*           collect_decls_sub_ps decls s *)
+  (*         else collect_decls_sub_ps decls s *)
+
+  (*   and collect_decls_sub decls s = collect_decls_sub_ps decls (List.map snd s) *)
+
+  (*   and collect_decls_ctx decls = function *)
+  (*     | [] -> decls *)
+  (*     | (_, (ty, _)) :: ctx -> collect_decls_ctx (collect_decls_ty decls ty) ctx *)
+
+  (*   let order_decls decls = *)
+  (*     let all_deps_done t ordered = *)
+  (*       let deps = *)
+  (*         match t with *)
+  (*         | VTm t -> collect_decls_checkedtm [] t *)
+  (*         | VCoh c -> collect_decls_coh [] c *)
+  (*       in *)
+  (*       List.for_all *)
+  (*         (fun (m, _) -> *)
+  (*           List.exists *)
+  (*             (fun (n, _) -> *)
+  (*               match (n, m) with *)
+  (*               | VTm t1, VTm t2 -> Tm.is_equal t1 t2 *)
+  (*               | VCoh c1, VCoh c2 -> Coh.is_equal c1 c2 *)
+  (*               | _, _ -> false) *)
+  (*             ordered) *)
+  (*         deps *)
+  (*     in *)
+  (*     let rec add_next decls ordered front = *)
+  (*       match decls with *)
+  (*       | [] -> assert false *)
+  (*       | (t, n) :: decls when all_deps_done t ordered -> *)
+  (*           (List.append front decls, (t, n) :: ordered) *)
+  (*       | (t, n) :: decls -> add_next decls ordered ((t, n) :: front) *)
+  (*     in *)
+  (*     let rec add_recursively decls ordered = *)
+  (*       match decls with *)
+  (*       | [] -> ordered *)
+  (*       | _ -> *)
+  (*           let decls, ordered = add_next decls ordered [] in *)
+  (*           add_recursively decls ordered *)
+  (*     in *)
+  (*     add_recursively decls [] *)
+
+  (*   let rec ty_to_string decls = function *)
+  (*     | Meta_ty _ -> assert false *)
+  (*     | Obj -> "*" *)
+  (*     | Arr (_, u, v) -> *)
+  (*         let u = tm_to_string decls u in *)
+  (*         let v = tm_to_string decls v in *)
+  (*         Printf.sprintf "%s -> %s" u v *)
+
+  (*   and tm_to_string decls t = *)
+  (*     match t with *)
+  (*     | Var v -> Var.to_string v *)
+  (*     | Meta_tm _ -> assert false *)
+  (*     | Coh (c, s) -> *)
+  (*         let c = *)
+  (*           match find (VCoh c) decls with Some c -> c | None -> assert false *)
+  (*         in *)
+  (*         let s = sub_ps_to_string decls s in *)
+  (*         Printf.sprintf "%s %s" c s *)
+  (*     | App (t, s) -> *)
+  (*         let t = *)
+  (*           match find (VTm t) decls with Some t -> t | None -> assert false *)
+  (*         in *)
+  (*         let s = sub_to_string decls s in *)
+  (*         Printf.sprintf "%s %s" t s *)
+
+  (*   and sub_ps_to_string decls s = *)
+  (*     match s with *)
+  (*     | [] -> "" *)
+  (*     | (t, expl) :: s -> *)
+  (*         if expl then *)
+  (*           let t = tm_to_string decls t in *)
+  (*           let s = sub_ps_to_string decls s in *)
+  (*           Printf.sprintf "%s (%s)" s t *)
+  (*         else sub_ps_to_string decls s *)
+
+  (*   and sub_to_string decls s = sub_ps_to_string decls (List.map snd s) *)
+
+  (*   let print_tm_in_ctx decls ctx tm = *)
+  (*     let rec print decls ctx res = *)
+  (*       match ctx with *)
+  (*       | [] -> "λ" ^ res *)
+  (*       | (x, (ty, true)) :: ctx -> *)
+  (*           let ty = ty_to_string decls ty in *)
+  (*           let res = Printf.sprintf "(%s,%s) %s" (Var.to_string x) ty res in *)
+  (*           print decls ctx res *)
+  (*       | (x, (ty, false)) :: ctx -> *)
+  (*           let ty = ty_to_string decls ty in *)
+  (*           let res = Printf.sprintf "{%s,%s} %s" (Var.to_string x) ty res in *)
+  (*           print decls ctx res *)
+  (*     in *)
+  (*     print decls ctx (Printf.sprintf "=> %s" tm) *)
+
+  (*   let print_tm t = *)
+  (*     let rec print_decls decls res = *)
+  (*       match decls with *)
+  (*       | [] -> res *)
+  (*       | (VTm t, name) :: decls -> *)
+  (*           let ctx = Tm.ctx t in *)
+  (*           let newtm = tm_to_string decls (Tm.develop t) in *)
+  (*           let newdecl = print_tm_in_ctx decls ctx newtm in *)
+  (*           let res = Printf.sprintf "let %s = %s in \n %s" name newdecl res in *)
+  (*           print_decls decls res *)
+  (*       | (VCoh c, name) :: decls -> *)
+  (*           let ps, ty, _ = Coh.forget c in *)
+  (*           let res = *)
+  (*             Printf.sprintf "let %s = Coh(%s, %s) in\n %s" name *)
+  (*               (Regular.ps_to_string ps) (ty_to_string decls ty) res *)
+  (*           in *)
+  (*           print_decls decls res *)
+  (*     in *)
+  (*     let decls = collect_decls_tm [] t in *)
+  (*     let decls = order_decls decls in *)
+  (*     let res = tm_to_string decls t in *)
+  (*     print_decls decls res *)
+  (* end *)
 
   let ps_to_string = Regular.ps_to_string
   let ty_to_string = Regular.ty_to_string
@@ -367,5 +365,8 @@ module Make (Core : Core.S) = struct
   let meta_ctx_to_string = Regular.meta_ctx_to_string
   let pp_data_to_string = Regular.pp_data_to_string
   let full_name = Regular.full_name
-  let print_kolmogorov = Kolmogorov.print_tm
+
+  (* let print_kolmogorov = Kolmogorov.print_tm *)
+  let print_kolmogorov =
+   fun _ -> Error.fatal "benchmarking has been temporarily deactivated"
 end
diff --git a/lib/internals/unchecked.ml b/lib/internals/unchecked.ml
index 7b762dc9..7da9efb2 100644
--- a/lib/internals/unchecked.ml
+++ b/lib/internals/unchecked.ml
@@ -135,17 +135,13 @@ module Make (Core : Core.S) = struct
 
   and suspend_tm = function
     | Var v -> Var (Var.suspend v)
-    | Coh (c, s) -> Coh (suspend_coh c, suspend_sub_ps s)
+    | Coh (c, s) -> Coh (Coh.suspend c, suspend_sub_ps s)
     | App (t, s) ->
         let t, _ = Tm.apply suspend_ctx suspend_tm suspend_pp_data t in
         let s = sub_ps_to_sub (sub_to_sub_ps s) in
         App (t, suspend_sub s)
     | Meta_tm _ -> Error.fatal "meta-variables should be resolved"
 
-  and suspend_coh c =
-    let p, t, pp_data = Coh.forget c in
-    Coh.check (suspend_ps p) (suspend_ty t) (suspend_pp_data pp_data)
-
   and suspend_sub_ps = function
     | [] -> [ (Var (Var.Db 1), false); (Var (Var.Db 0), false) ]
     | (t, expl) :: s -> (suspend_tm t, expl) :: suspend_sub_ps s
diff --git a/lib/internals/unchecked.mli b/lib/internals/unchecked.mli
index c888f001..9261427a 100644
--- a/lib/internals/unchecked.mli
+++ b/lib/internals/unchecked.mli
@@ -84,7 +84,7 @@ module Make (Core : Core.S) : sig
 
   val canonical_inclusions : ps list -> (Coh.t, Tm.t) sub_ps list
   val ty_to_sub_ps : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub_ps
-  val coh_to_sub_ps : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub_ps
+  val coh_to_sub_ps : (Coh.t, InnerTm.t) tm -> (Coh.t, InnerTm.t) sub_ps
 
   val ps_compose :
     int -> ps -> ps -> ps * (Coh.t, Tm.t) sub_ps * (Coh.t, Tm.t) sub_ps
diff --git a/lib/lib/common.ml b/lib/lib/common.ml
index 1149c689..c5a74bc0 100644
--- a/lib/lib/common.ml
+++ b/lib/lib/common.ml
@@ -64,6 +64,8 @@ and ('a, 'b) sub = (Var.t * (('a, 'b) tm * bool)) list
 type ('a, 'b) ctx = (Var.t * (('a, 'b) ty * bool)) list
 type ('a, 'b) meta_ctx = (int * ('a, 'b) ty) list
 type ('a, 'b) constr = ('a, 'b) tm * ('a, 'b) ty
+type ('a, 'b) value = VCoh of 'a | VTm of 'b
+type ('a, 'b) decls = (('a, 'b) value * string) list
 
 (* For application *)
 type pp_data = string * int * (Var.t * int) list list
diff --git a/lib/lib/common.mli b/lib/lib/common.mli
index d2b0d466..35aae4c7 100644
--- a/lib/lib/common.mli
+++ b/lib/lib/common.mli
@@ -39,6 +39,8 @@ type ('a, 'b) ctx = (Var.t * (('a, 'b) ty * bool)) list
 type ('a, 'b) meta_ctx = (int * ('a, 'b) ty) list
 type ('a, 'b) constr = ('a, 'b) tm * ('a, 'b) ty
 type pp_data = string * int * (Var.t * int) list list
+type ('a, 'b) value = VCoh of 'a | VTm of 'b
+type ('a, 'b) decls = (('a, 'b) value * string) list
 
 val take : int -> 'a list -> 'a list
 

From e17db6c06fccce7fbd0348e5e05684eb9874607e Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 4 Nov 2025 17:58:06 +0100
Subject: [PATCH 25/30] wip

---
 lib/internals/builder.ml    | 267 +++++++++++++++++++++++
 lib/internals/core.mli      |  14 +-
 lib/internals/kernel.ml     | 408 ++++++++++++------------------------
 lib/internals/kernel.mli    |  19 +-
 lib/internals/unchecked.mli |   2 +-
 5 files changed, 419 insertions(+), 291 deletions(-)
 create mode 100644 lib/internals/builder.ml

diff --git a/lib/internals/builder.ml b/lib/internals/builder.ml
new file mode 100644
index 00000000..a5abe4ac
--- /dev/null
+++ b/lib/internals/builder.ml
@@ -0,0 +1,267 @@
+open Std
+open Common
+
+module Make (Core : Core.S) = struct
+  exception IsObj
+  exception IsCoh
+  exception InvalidSubTarget of string * string
+  exception MetaVariable
+
+  open Core
+
+  (** Operations on substitutions. *)
+  module rec Sub : sig
+    type t
+
+    val to_list : t -> Tm.t list
+    val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
+    val forget : t -> (Coh.t, Tm.t) sub
+    val src : t -> Ctx.t
+    val tgt : t -> Ctx.t
+  end = struct
+    type t = {
+      list : Tm.t list;
+      src : Ctx.t;
+      tgt : Ctx.t;
+      unchecked : (Coh.t, Tm.t) sub;
+    }
+
+    let to_list s = s.list
+    let src s = s.src
+    let tgt s = s.tgt
+
+    module Core = struct
+      module PS = PS
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    let check src s tgt =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf
+             "building kernel substitution : source = %s; substitution = %s; \
+              target = %s"
+             (Ctx.to_string src) (Printing.sub_to_string s) (Ctx.to_string tgt)));
+      let sub_exn =
+        InvalidSubTarget (Printing.sub_to_string_debug s, Ctx.to_string tgt)
+      in
+      let rec aux src s tgt =
+        let expr s tgt =
+          match (s, Ctx.value tgt) with
+          | [], [] -> []
+          | _ :: _, [] | [], _ :: _ -> raise sub_exn
+          | (x1, _) :: _, (x2, _) :: _ when x1 <> x2 -> raise sub_exn
+          | (_, (t, _)) :: s, (_, a) :: _ ->
+              let sub = aux src s (Ctx.tail tgt) in
+              let t = Tm.check (Ctx.forget src) t in
+              let asub =
+                Unchecked.ty_apply_sub (Ty.forget a) (Sub.forget sub)
+              in
+              if not (Equality.is_equal_ty (Tm.ty t) asub) then
+                raise
+                  (NotEqual
+                     ( Printing.ty_to_string (Tm.ty t),
+                       Printing.ty_to_string asub ));
+
+              t :: sub.list
+        in
+        { list = expr s tgt; src; tgt; unchecked = s }
+      in
+      aux src s tgt
+
+    let forget s = s.unchecked
+  end
+
+  (** A context, associating a type to each context variable. *)
+  and Ctx : sig
+    type t
+
+    val empty : unit -> t
+    val tail : t -> t
+    val to_string : t -> string
+    val ty_var : t -> Var.t -> Ty.t
+    val domain : t -> Var.t list
+    val value : t -> (Var.t * Ty.t) list
+    val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
+    val forget : t -> (Coh.t, Tm.t) ctx
+    val check : (Coh.t, Tm.t) ctx -> t
+    val check_notin : t -> Var.t -> unit
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+  end = struct
+    type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
+
+    module Core = struct
+      module PS = PS
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
+
+    let tail ctx =
+      match (ctx.c, ctx.unchecked) with
+      | [], (_ :: _ | []) -> Error.fatal "computing tail of an empty context"
+      | _ :: _, [] -> Error.fatal "safe and unchecked context out of sync"
+      | _ :: c, _ :: unchecked -> { c; unchecked }
+
+    let ty_var ctx x =
+      try List.assoc x ctx.c
+      with Not_found -> raise (Error.UnknownId (Var.to_string x))
+
+    let empty () = { c = []; unchecked = [] }
+    let domain ctx = List.map fst ctx.c
+    let value ctx = ctx.c
+    let forget c = c.unchecked
+    let to_string ctx = Printing.ctx_to_string (forget ctx)
+
+    let is_equal ctx1 ctx2 =
+      ctx1 == ctx2 || Equality.is_equal_ctx (forget ctx1) (forget ctx2)
+
+    let check_equal ctx1 ctx2 =
+      if not (is_equal ctx1 ctx2) then
+        raise
+          (NotEqual
+             ( Printing.ctx_to_string (forget ctx1),
+               Printing.ctx_to_string (forget ctx2) ))
+
+    let check_notin ctx x =
+      try
+        ignore (List.assoc x ctx.c);
+        raise (DoubledVar (Var.to_string x))
+      with Not_found -> ()
+
+    let extend ctx ~expl x t =
+      let ty = Ty.check ctx t in
+      Ctx.check_notin ctx x;
+      {
+        c = (x, ty) :: Ctx.value ctx;
+        unchecked = (x, (t, expl)) :: Ctx.forget ctx;
+      }
+
+    let check c =
+      match Hashtbl.find_opt tbl c with
+      | Some ctx -> ctx
+      | None ->
+          let ctx =
+            List.fold_right
+              (fun (x, (t, expl)) c -> Ctx.extend ~expl c x t)
+              c (Ctx.empty ())
+          in
+          Hashtbl.add tbl c ctx;
+          ctx
+  end
+
+  and Ty : sig
+    type t
+
+    val to_string : t -> string
+    val is_obj : t -> bool
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val morphism : Tm.t -> Tm.t -> Ty.t
+    val forget : t -> (Coh.t, Tm.t) ty
+    val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
+    val apply_sub : t -> Sub.t -> t
+    val retrieve_arrow : t -> Tm.t * Tm.t
+    val under_type : t -> t
+    val source : t -> Tm.t
+    val target : t -> Tm.t
+    val ctx : t -> Ctx.t
+    val dim : t -> int
+  end = struct
+    module Core = struct
+      module PS = PS
+      module Coh = Coh
+      module Tm = Tm
+    end
+
+    open Syntax.Make (Core)
+
+    (** A type exepression. *)
+    type expr = Obj | Arr of t * Tm.t * Tm.t
+
+    and t = { c : Ctx.t; e : expr; unchecked : ty }
+
+    let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
+    let is_obj t = t.e = Obj
+
+    let retrieve_arrow ty =
+      match ty.e with
+      | Obj ->
+          Error.fatal
+            "calling source and target on a type that is not an arrow type"
+      | Arr (_, u, v) -> (u, v)
+
+    let under_type ty =
+      match ty.e with Obj -> raise IsObj | Arr (a, _, _) -> a
+
+    let source ty = match ty.e with Obj -> raise IsObj | Arr (_, u, _) -> u
+    let target ty = match ty.e with Obj -> raise IsObj | Arr (_, _, v) -> v
+
+    let rec check c t =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "building kernel type %s in context %s"
+             (Printing.ty_to_string t) (Ctx.to_string c)));
+      match Hashtbl.find_opt tbl (c, t) with
+      | Some ty -> ty
+      | None ->
+          let e =
+            match t with
+            | Obj -> Obj
+            | Arr (a, u, v) ->
+                let achecked = check c a in
+                let u = Tm.check (Ctx.forget c) ~ty:a u in
+                let v = Tm.check (Ctx.forget c) ~ty:a v in
+                Arr (achecked, u, v)
+            | Meta_ty _ -> raise MetaVariable
+          in
+          let ty = { c; e; unchecked = t } in
+          Hashtbl.add tbl (c, t) ty;
+          ty
+
+    let forget t = t.unchecked
+    let to_string ty = Printing.ty_to_string (forget ty)
+
+    let is_equal ty1 ty2 =
+      Ctx.is_equal ty1.c ty2.c && Equality.is_equal_ty (forget ty1) (forget ty2)
+
+    let check_equal ty1 ty2 =
+      if not (is_equal ty1 ty2) then
+        raise
+          (NotEqual
+             ( Printing.ty_to_string (forget ty1),
+               Printing.ty_to_string (forget ty2) ))
+
+    let morphism t1 t2 =
+      let a = Tm.ty t1 in
+      let c = Tm.ctx t1 in
+      if
+        not
+          (Equality.is_equal_ctx c (Tm.ctx t2)
+          && Equality.is_equal_ty a (Tm.ty t2))
+      then
+        raise
+          (NotEqual (Printing.ty_to_string a, Printing.ty_to_string (Tm.ty t2)));
+      let c = Ctx.check c in
+      let a_checked = check c a in
+      {
+        c;
+        e = Arr (a_checked, t1, t2);
+        unchecked = Arr (a, Tm.forget t1, Tm.forget t2);
+      }
+
+    let apply_sub t s =
+      Ctx.check_equal t.c (Sub.tgt s);
+      check (Sub.src s) (Unchecked.ty_apply_sub (forget t) (Sub.forget s))
+
+    let ctx t = t.c
+    let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
+  end
+end
diff --git a/lib/internals/core.mli b/lib/internals/core.mli
index 546606b2..45c78482 100644
--- a/lib/internals/core.mli
+++ b/lib/internals/core.mli
@@ -1,18 +1,16 @@
 open Common
 
 module type S = sig
-  module InnerTm : sig
+  module PS : sig
     type t
   end
 
   module Coh : sig
     type t
+    type innertm
 
     val suspend : t -> t
-
-    (* val collect_decls : t -> (t, InnerTm.t) decls -> (t, InnerTm.t) decls *)
-    (* val to_string_kolmogorov : t -> (t, InnerTm.t) decls -> string *)
-    val forget : t -> ps * (t, InnerTm.t) ty * pp_data
+    val forget : t -> ps * (t, innertm) ty * pp_data
     val to_string : ?unroll:bool -> t -> string
     val func_data : t -> (Var.t * int) list list
     val is_equal : t -> t -> bool
@@ -28,6 +26,12 @@ module type S = sig
     val ctx : t -> (Coh.t, t) ctx
     val is_equal : t -> t -> bool
 
+    val check :
+      (Coh.t, t) ctx -> ?ty:(Coh.t, t) ty -> ?name:pp_data -> (Coh.t, t) tm -> t
+
+    val ty : t -> (Coh.t, t) ty
+    val forget : t -> (Coh.t, t) tm
+
     val apply :
       ((Coh.t, t) ctx -> (Coh.t, t) ctx) ->
       ((Coh.t, t) tm -> (Coh.t, t) tm) ->
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index f05821c9..33c2796c 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -1,168 +1,50 @@
 open Std
 open Common
+module CoreSignature = Core
 
-exception IsObj
 exception IsCoh
-exception InvalidSubTarget of string * string
 exception MetaVariable
 
 module Make (Theory : Theory.S) = struct
   (** Operations on substitutions. *)
   module rec Sub : sig
-    type t
-
-    val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
-    val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> t
-    val forget : t -> (Coh.t, Tm.t) sub
-    val free_vars : t -> Var.t list
-    val src : t -> Ctx.t
-    val tgt : t -> Ctx.t
+    type t = B.Sub.t
+
+    val check : B.Ctx.t -> (Coh.t, Tm.t) sub -> B.Ctx.t -> B.Sub.t
+    val check_to_ps : B.Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> B.Sub.t
+    val forget : B.Sub.t -> (Coh.t, Tm.t) sub
+    val free_vars : B.Sub.t -> Var.t list
+    val src : B.Sub.t -> B.Ctx.t
+    val tgt : B.Sub.t -> B.Ctx.t
   end = struct
-    type t = {
-      list : Tm.t list;
-      src : Ctx.t;
-      tgt : Ctx.t;
-      unchecked : (Coh.t, Tm.t) sub;
-    }
-
-    let src s = s.src
-    let tgt s = s.tgt
-
-    module Core = struct
-      module InnerTm = Tm
-      module Coh = Coh
-      module Tm = Tm
-    end
-
-    open Syntax.Make (Core)
+    include B.Sub
 
-    let tbl : (Ctx.t * PS.t * sub_ps, Sub.t) Hashtbl.t = Hashtbl.create 7829
-    let free_vars s = List.concat (List.map Tm.free_vars s.list)
-
-    let check src s tgt =
-      Io.info ~v:5
-        (lazy
-          (Printf.sprintf
-             "building kernel substitution : source = %s; substitution = %s; \
-              target = %s"
-             (Ctx.to_string src) (Printing.sub_to_string s) (Ctx.to_string tgt)));
-      let sub_exn =
-        InvalidSubTarget (Printing.sub_to_string_debug s, Ctx.to_string tgt)
-      in
-      let rec aux src s tgt =
-        let expr s tgt =
-          match (s, Ctx.value tgt) with
-          | [], [] -> []
-          | _ :: _, [] | [], _ :: _ -> raise sub_exn
-          | (x1, _) :: _, (x2, _) :: _ when x1 <> x2 -> raise sub_exn
-          | (_, (t, _)) :: s, (_, a) :: _ ->
-              let sub = aux src s (Ctx.tail tgt) in
-              let t = Tm.check src t in
-              Ty.check_equal (Tm.typ t) (Ty.apply_sub a sub);
-              t :: sub.list
-        in
-        { list = expr s tgt; src; tgt; unchecked = s }
-      in
-      aux src s tgt
+    let free_vars s = List.concat (List.map Tm.free_vars (to_list s))
 
     let check_to_ps src s tgt_ps =
-      match Hashtbl.find_opt tbl (src, tgt_ps, s) with
-      | Some sub -> sub
-      | None ->
-          let tgt = PS.to_ctx tgt_ps in
-          let s_assoc =
-            try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) (Ctx.value tgt) s
-            with Invalid_argument _ ->
-              Error.fatal "uncaught wrong number of arguments"
-          in
-          let sub = check src s_assoc tgt in
-          Hashtbl.add tbl (src, tgt_ps, s) sub;
-          sub
-
-    let forget s = s.unchecked
+      let tgt = PS.to_ctx tgt_ps in
+      let s_assoc =
+        try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) (Ctx.value tgt) s
+        with Invalid_argument _ ->
+          Error.fatal "uncaught wrong number of arguments"
+      in
+      check src s_assoc tgt
   end
 
   (** A context, associating a type to each context variable. *)
   and Ctx : sig
-    type t
+    type t = B.Ctx.t
 
-    val empty : unit -> t
-    val tail : t -> t
     val to_string : t -> string
-    val ty_var : t -> Var.t -> Ty.t
+    val ty_var : t -> Var.t -> B.Ty.t
     val domain : t -> Var.t list
-    val value : t -> (Var.t * Ty.t) list
-    val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
+    val value : t -> (Var.t * B.Ty.t) list
     val forget : t -> (Coh.t, Tm.t) ctx
     val check : (Coh.t, Tm.t) ctx -> t
-    val check_notin : t -> Var.t -> unit
     val is_equal : t -> t -> bool
     val check_equal : t -> t -> unit
-  end = struct
-    type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
-
-    module Core = struct
-      module InnerTm = Tm
-      module Coh = Coh
-      module Tm = Tm
-    end
-
-    open Syntax.Make (Core)
-
-    let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
-
-    let tail ctx =
-      match (ctx.c, ctx.unchecked) with
-      | [], (_ :: _ | []) -> Error.fatal "computing tail of an empty context"
-      | _ :: _, [] -> Error.fatal "safe and unchecked context out of sync"
-      | _ :: c, _ :: unchecked -> { c; unchecked }
-
-    let ty_var ctx x =
-      try List.assoc x ctx.c
-      with Not_found -> raise (Error.UnknownId (Var.to_string x))
-
-    let empty () = { c = []; unchecked = [] }
-    let domain ctx = List.map fst ctx.c
-    let value ctx = ctx.c
-    let forget c = c.unchecked
-    let to_string ctx = Printing.ctx_to_string (forget ctx)
-
-    let is_equal ctx1 ctx2 =
-      ctx1 == ctx2 || Equality.is_equal_ctx (forget ctx1) (forget ctx2)
-
-    let check_equal ctx1 ctx2 =
-      if not (is_equal ctx1 ctx2) then
-        raise
-          (NotEqual
-             ( Printing.ctx_to_string (forget ctx1),
-               Printing.ctx_to_string (forget ctx2) ))
-
-    let check_notin ctx x =
-      try
-        ignore (List.assoc x ctx.c);
-        raise (DoubledVar (Var.to_string x))
-      with Not_found -> ()
-
-    let extend ctx ~expl x t =
-      let ty = Ty.check ctx t in
-      Ctx.check_notin ctx x;
-      {
-        c = (x, ty) :: Ctx.value ctx;
-        unchecked = (x, (t, expl)) :: Ctx.forget ctx;
-      }
-
-    let check c =
-      match Hashtbl.find_opt tbl c with
-      | Some ctx -> ctx
-      | None ->
-          let ctx =
-            List.fold_right
-              (fun (x, (t, expl)) c -> Ctx.extend ~expl c x t)
-              c (Ctx.empty ())
-          in
-          Hashtbl.add tbl c ctx;
-          ctx
-  end
+  end =
+    B.Ctx
 
   (** Operations on pasting schemes. *)
   and PS : sig
@@ -174,19 +56,13 @@ module Make (Theory : Theory.S) = struct
     val mk : Ctx.t -> t
     val to_ctx : t -> Ctx.t
     val bdry : t -> t
-    val source : t -> Sub.t
-    val target : t -> Sub.t
+    val source : t -> B.Sub.t
+    val target : t -> B.Sub.t
     val forget : t -> ps
     val is_equal : t -> t -> bool
   end = struct
     exception Invalid
 
-    module Core = struct
-      module InnerTm = Tm
-      module Coh = Coh
-      module Tm = Tm
-    end
-
     open Syntax.Make (Core)
 
     (** A pasting scheme. *)
@@ -197,8 +73,6 @@ module Make (Theory : Theory.S) = struct
 
     type t = { tree : ps; ctx : Ctx.t }
 
-    (* TODO:fix level of explicitness here *)
-
     let tbl : (Ctx.t, PS.t) Hashtbl.t = Hashtbl.create 7829
 
     (** Create a context from a pasting scheme. *)
@@ -219,8 +93,8 @@ module Make (Theory : Theory.S) = struct
       | PCons (_, _, f) -> f
       | PDrop ps ->
           let _, tf = marker ps in
-          let v = try Ty.target tf with IsObj -> raise Invalid in
-          let y = try Tm.to_var v with IsCoh -> raise Invalid in
+          let v = try Ty.target tf with B.IsObj -> raise Invalid in
+          let y = try Tm.to_var v with B.IsCoh -> raise Invalid in
           let t =
             let rec aux = function
               | PNil (x, t) ->
@@ -251,10 +125,10 @@ module Make (Theory : Theory.S) = struct
         let rec aux ps = function
           | (y, ty) :: (f, tf) :: l as l1 ->
               let u, v =
-                try Ty.retrieve_arrow tf with IsObj -> raise Invalid
+                try Ty.retrieve_arrow tf with B.IsObj -> raise Invalid
               in
               let fx, fy =
-                try (Tm.to_var u, Tm.to_var v) with IsCoh -> raise Invalid
+                try (Tm.to_var u, Tm.to_var v) with B.IsCoh -> raise Invalid
               in
               if y <> fy then raise Invalid;
               let x, _ = marker ps in
@@ -323,7 +197,7 @@ module Make (Theory : Theory.S) = struct
   end
 
   and Ty : sig
-    type t
+    type t = B.Ty.t
 
     val to_string : t -> string
     val free_vars : t -> Var.t list
@@ -332,107 +206,30 @@ module Make (Theory : Theory.S) = struct
     val is_obj : t -> bool
     val is_equal : t -> t -> bool
     val check_equal : t -> t -> unit
-    val morphism : Tm.t -> Tm.t -> Ty.t
+    val morphism : Tm.t -> Tm.t -> t
     val forget : t -> (Coh.t, Tm.t) ty
-    val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
-    val apply_sub : t -> Sub.t -> t
+    val check : B.Ctx.t -> (Coh.t, Tm.t) ty -> t
+    val apply_sub : t -> B.Sub.t -> t
     val retrieve_arrow : t -> Tm.t * Tm.t
     val under_type : t -> t
     val source : t -> Tm.t
     val target : t -> Tm.t
-    val ctx : t -> Ctx.t
+    val ctx : t -> B.Ctx.t
     val dim : t -> int
   end = struct
-    module Core = struct
-      module InnerTm = Tm
-      module Coh = Coh
-      module Tm = Tm
-    end
+    include B.Ty
 
-    open Syntax.Make (Core)
-
-    (** A type exepression. *)
-    type expr = Obj | Arr of t * Tm.t * Tm.t
-
-    and t = { c : Ctx.t; e : expr; unchecked : ty }
-
-    let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
-    let is_obj t = t.e = Obj
-
-    let retrieve_arrow ty =
-      match ty.e with
-      | Obj ->
-          Error.fatal
-            "calling source and target on a type that is not an arrow type"
-      | Arr (_, u, v) -> (u, v)
-
-    let under_type ty =
-      match ty.e with Obj -> raise IsObj | Arr (a, _, _) -> a
-
-    let source ty = match ty.e with Obj -> raise IsObj | Arr (_, u, _) -> u
-    let target ty = match ty.e with Obj -> raise IsObj | Arr (_, _, v) -> v
-
-    let rec check c t =
-      Io.info ~v:5
-        (lazy
-          (Printf.sprintf "building kernel type %s in context %s"
-             (Printing.ty_to_string t) (Ctx.to_string c)));
-      match Hashtbl.find_opt tbl (c, t) with
-      | Some ty -> ty
-      | None ->
-          let e =
-            match t with
-            | Obj -> Obj
-            | Arr (a, u, v) ->
-                let a = check c a in
-                let u = Tm.check c ~ty:a u in
-                let v = Tm.check c ~ty:a v in
-                Arr (a, u, v)
-            | Meta_ty _ -> raise MetaVariable
-          in
-          let ty = { c; e; unchecked = t } in
-          Hashtbl.add tbl (c, t) ty;
-          ty
-
-    (** Free variables of a type. *)
-    let rec free_vars ty =
-      match ty.e with
-      | Obj -> []
-      | Arr (t, u, v) ->
-          List.unions [ free_vars t; Tm.free_vars u; Tm.free_vars v ]
+    let rec free_vars (ty : t) =
+      if Ty.is_obj ty then []
+      else
+        let t, u, v = (Ty.under_type ty, Ty.source ty, Ty.target ty) in
+        List.unions [ free_vars t; Tm.free_vars u; Tm.free_vars v ]
 
     (* TODO: remove is_full *)
-    let contains_all_vars t = List.included (Ctx.domain t.c) (free_vars t)
+    let contains_all_vars (t : t) =
+      List.included (Ctx.domain (Ty.ctx t)) (free_vars t)
+
     let is_full t = contains_all_vars t
-    let forget t = t.unchecked
-    let to_string ty = Printing.ty_to_string (forget ty)
-
-    let is_equal ty1 ty2 =
-      Ctx.is_equal ty1.c ty2.c && Equality.is_equal_ty (forget ty1) (forget ty2)
-
-    let check_equal ty1 ty2 =
-      if not (is_equal ty1 ty2) then
-        raise
-          (NotEqual
-             ( Printing.ty_to_string (forget ty1),
-               Printing.ty_to_string (forget ty2) ))
-
-    let morphism t1 t2 =
-      let a1 = Tm.typ t1 in
-      let a2 = Tm.typ t2 in
-      check_equal a1 a2;
-      {
-        c = a1.c;
-        e = Arr (a1, t1, t2);
-        unchecked = Arr (forget a1, Tm.forget t1, Tm.forget t2);
-      }
-
-    let apply_sub t s =
-      Ctx.check_equal t.c (Sub.tgt s);
-      check (Sub.src s) (Unchecked.ty_apply_sub (forget t) (Sub.forget s))
-
-    let ctx t = t.c
-    let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
   end
 
   (** Operations on terms. *)
@@ -460,9 +257,19 @@ module Make (Theory : Theory.S) = struct
 
     (* Production of terms *)
     val of_coh : Coh.t -> t
-    val check : Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
-    val apply_sub : t -> Sub.t -> t
-    val preimage : t -> Sub.t -> t
+
+    val check_in_ctx :
+      Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
+
+    val check :
+      (Coh.t, Tm.t) ctx ->
+      ?ty:(Coh.t, Tm.t) ty ->
+      ?name:pp_data ->
+      (Coh.t, Tm.t) tm ->
+      t
+
+    val apply_sub : t -> B.Sub.t -> t
+    val preimage : t -> B.Sub.t -> t
     val develop : t -> (Coh.t, Tm.t) tm
 
     val apply :
@@ -474,15 +281,9 @@ module Make (Theory : Theory.S) = struct
 
     val is_equal : t -> t -> bool
   end = struct
-    module Core = struct
-      module InnerTm = Tm
-      module Coh = Coh
-      module Tm = Tm
-    end
-
     open Syntax.Make (Core)
 
-    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
+    type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
 
     and t = {
       ty : Ty.t;
@@ -510,7 +311,7 @@ module Make (Theory : Theory.S) = struct
     let forget tm = tm.unchecked
     let constr tm = (forget tm, ty tm)
 
-    let check c ?ty ?name t =
+    let check_in_ctx c ?ty ?name t =
       Io.info ~v:5
         (lazy
           (Printf.sprintf "building kernel term %s in context %s"
@@ -544,6 +345,11 @@ module Make (Theory : Theory.S) = struct
           Ty.check_equal ty tm.ty;
           tm
 
+    let check c ?ty ?name tm =
+      let c = Ctx.check c in
+      let ty = Option.map (Ty.check c) ty in
+      check_in_ctx c ?ty ?name tm
+
     let develop tm =
       match tm.developped with
       | Some t -> t
@@ -574,13 +380,13 @@ module Make (Theory : Theory.S) = struct
       let c = Sub.src sub in
       let ty = Ty.apply_sub t.ty sub in
       let t = Unchecked.tm_apply_sub (forget t) (Sub.forget sub) in
-      check c ~ty t
+      check_in_ctx c ~ty t
 
     let preimage t sub =
       Ctx.check_equal (Sub.src sub) (Ty.ctx t.ty);
       let c = Sub.tgt sub in
       let t = Unchecked.tm_sub_preimage (forget t) (Sub.forget sub) in
-      check c t
+      check_in_ctx c t
 
     let is_equal t1 t2 =
       Ctx.is_equal (Ty.ctx t1.ty) (Ty.ctx t2.ty)
@@ -598,7 +404,7 @@ module Make (Theory : Theory.S) = struct
             Display_maps.pp_data_rename (fun_pp_data pp_data) db_sub)
           tm.name
       in
-      (check c ?name newexp, db_sub)
+      (check_in_ctx c ?name newexp, db_sub)
 
     let bdry t = (Ty.source (typ t), Ty.target (typ t))
     let ctx t = Ctx.forget (Ty.ctx (typ t))
@@ -616,12 +422,13 @@ module Make (Theory : Theory.S) = struct
       let ps, _, pp_data = Coh.forget coh in
       let id = Unchecked.identity_ps ps in
       let ctx = Unchecked.ps_to_ctx ps in
-      check (Ctx.check ctx) ~name:pp_data (Coh (coh, id))
+      check_in_ctx (Ctx.check ctx) ~name:pp_data (Coh (coh, id))
   end
 
   (** A coherence. *)
   and Coh : sig
     type t
+    type innertm = Tm.t
 
     val ps : t -> PS.t
     val ty : t -> Ty.t
@@ -654,16 +461,11 @@ module Make (Theory : Theory.S) = struct
       t ->
       t * (t, Tm.t) sub
   end = struct
+    type innertm = Tm.t
     type cohInv = { ps : PS.t; ty : Ty.t }
     type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
     type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
 
-    module Core = struct
-      module InnerTm = Tm
-      module Coh = Coh
-      module Tm = Tm
-    end
-
     open Syntax.Make (Core)
 
     let tbl : (ps * ty, Coh.t) Hashtbl.t = Hashtbl.create 7829
@@ -728,10 +530,10 @@ module Make (Theory : Theory.S) = struct
           let tgt_inclusion = PS.target ps in
           let bdry = PS.bdry ps in
           let cbdry = PS.to_ctx bdry in
-          let src = Tm.check cbdry src_unchkd in
+          let src = Tm.check_in_ctx cbdry src_unchkd in
           if not (Tm.is_full src) then raise NotAlgebraic
           else
-            let tgt = Tm.check cbdry tgt_unchkd in
+            let tgt = Tm.check_in_ctx cbdry tgt_unchkd in
             if not (Tm.is_full tgt) then raise NotAlgebraic
             else
               let total_ty =
@@ -749,8 +551,8 @@ module Make (Theory : Theory.S) = struct
       | None ->
           let ctx = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
           let ps = PS.mk ctx in
-          let src = Tm.check ctx src_unchkd in
-          let tgt = Tm.check ctx tgt_unchkd in
+          let src = Tm.check_in_ctx ctx src_unchkd in
+          let tgt = Tm.check_in_ctx ctx tgt_unchkd in
           let ty = Ty.morphism src tgt in
           if Ty.is_full ty then (
             let coh = Inv ({ ps; ty }, name) in
@@ -824,12 +626,66 @@ module Make (Theory : Theory.S) = struct
       (check ps ty pp_data, db_sub)
   end
 
-  module Core = struct
-    module InnerTm = Tm
-    module Coh = Coh
+  and Core :
+    (CoreSignature.S
+      with type PS.t = PS.t
+      with type Coh.t = Coh.t
+      with type Tm.t = Tm.t) = struct
+    module PS = PS
     module Tm = Tm
+    module Coh = Coh
   end
 
+  and B : sig
+    exception IsObj
+    exception IsCoh
+    exception InvalidSubTarget of string * string
+    exception MetaVariable
+
+    module rec Sub : sig
+      type t
+
+      val to_list : t -> Tm.t list
+      val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
+      val forget : t -> (Coh.t, Tm.t) sub
+      val src : t -> Ctx.t
+      val tgt : t -> Ctx.t
+    end
+
+    and Ctx : sig
+      type t
+
+      val to_string : t -> string
+      val ty_var : t -> Var.t -> Ty.t
+      val domain : t -> Var.t list
+      val value : t -> (Var.t * Ty.t) list
+      val forget : t -> (Coh.t, Tm.t) ctx
+      val check : (Coh.t, Tm.t) ctx -> t
+      val is_equal : t -> t -> bool
+      val check_equal : t -> t -> unit
+    end
+
+    and Ty : sig
+      type t
+
+      val to_string : t -> string
+      val is_obj : t -> bool
+      val is_equal : t -> t -> bool
+      val check_equal : t -> t -> unit
+      val morphism : Tm.t -> Tm.t -> Ty.t
+      val forget : t -> (Coh.t, Tm.t) ty
+      val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
+      val apply_sub : t -> Sub.t -> t
+      val retrieve_arrow : t -> Tm.t * Tm.t
+      val under_type : t -> t
+      val source : t -> Tm.t
+      val target : t -> Tm.t
+      val ctx : t -> Ctx.t
+      val dim : t -> int
+    end
+  end =
+    Builder.Make (Core)
+
   include Syntax.Make (Core)
 
   let check check_fn name =
@@ -841,7 +697,7 @@ module Make (Theory : Theory.S) = struct
         Error.untypable
           (if !Settings.verbosity >= v then fname else Lazy.force name)
           (Printf.sprintf "%s and %s are not equal" s1 s2)
-    | InvalidSubTarget (s, tgt) ->
+    | B.InvalidSubTarget (s, tgt) ->
         Error.untypable
           (if !Settings.verbosity >= v then fname else Lazy.force name)
           (Printf.sprintf "substitution %s does not apply from context %s" s tgt)
@@ -860,7 +716,7 @@ module Make (Theory : Theory.S) = struct
   let check_term ctx ?ty ?name t =
     let ty = Option.map (check_type ctx) ty in
     let tm = lazy ("term: " ^ Printing.tm_to_string t) in
-    check (fun () -> Tm.check ctx ?ty ?name t) tm
+    check (fun () -> Tm.check_in_ctx ctx ?ty ?name t) tm
 
   let check_constr ?name ctx constr =
     let ctx = Ctx.check ctx in
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index d18d56f5..aa3b22b5 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -3,6 +3,7 @@ open Common
 module Make (_ : Theory.S) : sig
   module rec Coh : sig
     type t
+    type innertm = Tm.t
 
     val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
     val suspend : t -> t
@@ -64,6 +65,9 @@ module Make (_ : Theory.S) : sig
     val to_string : t -> string
     val is_equal : t -> t -> bool
 
+    val check :
+      (Coh.t, t) ctx -> ?ty:(Coh.t, t) ty -> ?name:pp_data -> (Coh.t, t) tm -> t
+
     val apply :
       ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
       ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
@@ -72,18 +76,10 @@ module Make (_ : Theory.S) : sig
       t * (Coh.t, Tm.t) sub
   end
 
-  module Core : sig
-    module InnerTm = Tm
-    module Coh = Coh
-    module Tm = Tm
-  end
-
-  include module type of Syntax.Make (Core)
-
   module Ctx : sig
     type t
 
-    val check : ctx -> t
+    val check : (Coh.t, Tm.t) ctx -> t
   end
 
   module PS : sig
@@ -95,6 +91,11 @@ module Make (_ : Theory.S) : sig
     val forget : t -> ps
   end
 
+  module Core :
+    Core.S with type PS.t = PS.t with type Coh.t = Coh.t with type Tm.t = Tm.t
+
+  include module type of Syntax.Make (Core)
+
   val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
   val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
   val check_coh : ps -> ty -> pp_data -> Coh.t
diff --git a/lib/internals/unchecked.mli b/lib/internals/unchecked.mli
index 9261427a..e0f3c41e 100644
--- a/lib/internals/unchecked.mli
+++ b/lib/internals/unchecked.mli
@@ -84,7 +84,7 @@ module Make (Core : Core.S) : sig
 
   val canonical_inclusions : ps list -> (Coh.t, Tm.t) sub_ps list
   val ty_to_sub_ps : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub_ps
-  val coh_to_sub_ps : (Coh.t, InnerTm.t) tm -> (Coh.t, InnerTm.t) sub_ps
+  val coh_to_sub_ps : (Coh.t, Coh.innertm) tm -> (Coh.t, Coh.innertm) sub_ps
 
   val ps_compose :
     int -> ps -> ps -> ps * (Coh.t, Tm.t) sub_ps * (Coh.t, Tm.t) sub_ps

From 4fcc4caf2058422538f9959b7024250a8bd04857 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 7 Nov 2025 22:05:39 +0100
Subject: [PATCH 26/30] cleanup the kernel with private types

---
 lib/elaboration/elaborate.ml             |   4 +-
 lib/internals/builder.ml                 | 108 ++------
 lib/internals/fullness.ml                | 145 +++++++---
 lib/internals/fullness.mli               |  81 ++++--
 lib/internals/kernel.ml                  | 320 +++++++++--------------
 lib/internals/kernel.mli                 |  26 +-
 lib/lib/environments.ml                  |   2 +-
 lib/meta_operations/cubical_composite.ml |   2 +-
 lib/meta_operations/functorialisation.ml |   2 +-
 lib/meta_operations/padding.ml           |  28 +-
 10 files changed, 348 insertions(+), 370 deletions(-)

diff --git a/lib/elaboration/elaborate.ml b/lib/elaboration/elaborate.ml
index 63de8744..dc7c423d 100644
--- a/lib/elaboration/elaborate.ml
+++ b/lib/elaboration/elaborate.ml
@@ -223,7 +223,7 @@ module Make (Environment : Environments.S) = struct
             Unchecked.ty_apply_sub ty s1 )
       | App (t, s) ->
           let tgt = Tm.ctx t in
-          let ty = Ty.forget (Tm.typ t) in
+          let ty = t.ty.unchecked in
           let s = sub ctx meta_ctx s tgt cst in
           (App (t, s), Unchecked.ty_apply_sub ty s)
 
@@ -362,7 +362,7 @@ module Make (Environment : Environments.S) = struct
       in
       try
         let _, names, _ = Unchecked.db_levels ps in
-        (PS.(forget (mk (Ctx.check ps))), Unchecked.rename_ty t names)
+        ((PS.mk (Ctx.check ps)).tree, Unchecked.rename_ty t names)
       with
       | PS.Invalid -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
       | DoubledVar x -> raise (Error.doubled_var (Printing.ctx_to_string ps) x)
diff --git a/lib/internals/builder.ml b/lib/internals/builder.ml
index a5abe4ac..28fe2749 100644
--- a/lib/internals/builder.ml
+++ b/lib/internals/builder.ml
@@ -11,13 +11,14 @@ module Make (Core : Core.S) = struct
 
   (** Operations on substitutions. *)
   module rec Sub : sig
-    type t
+    type t = private {
+      list : Tm.t list;
+      src : Ctx.t;
+      tgt : Ctx.t;
+      unchecked : (Coh.t, Tm.t) sub;
+    }
 
-    val to_list : t -> Tm.t list
     val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
-    val forget : t -> (Coh.t, Tm.t) sub
-    val src : t -> Ctx.t
-    val tgt : t -> Ctx.t
   end = struct
     type t = {
       list : Tm.t list;
@@ -26,16 +27,6 @@ module Make (Core : Core.S) = struct
       unchecked : (Coh.t, Tm.t) sub;
     }
 
-    let to_list s = s.list
-    let src s = s.src
-    let tgt s = s.tgt
-
-    module Core = struct
-      module PS = PS
-      module Coh = Coh
-      module Tm = Tm
-    end
-
     open Syntax.Make (Core)
 
     let check src s tgt =
@@ -48,43 +39,37 @@ module Make (Core : Core.S) = struct
       let sub_exn =
         InvalidSubTarget (Printing.sub_to_string_debug s, Ctx.to_string tgt)
       in
-      let rec aux src s tgt =
-        let expr s tgt =
-          match (s, Ctx.value tgt) with
+      let aux src s (tgt : Ctx.t) =
+        let rec list s (tgt : (Var.t * Ty.t) list) =
+          match (s, tgt) with
           | [], [] -> []
           | _ :: _, [] | [], _ :: _ -> raise sub_exn
           | (x1, _) :: _, (x2, _) :: _ when x1 <> x2 -> raise sub_exn
-          | (_, (t, _)) :: s, (_, a) :: _ ->
-              let sub = aux src s (Ctx.tail tgt) in
+          | (_, (t, _)) :: s, (_, a) :: tgt_tail ->
+              let sub_checked = list s tgt_tail in
               let t = Tm.check (Ctx.forget src) t in
-              let asub =
-                Unchecked.ty_apply_sub (Ty.forget a) (Sub.forget sub)
-              in
+              let asub = Unchecked.ty_apply_sub a.unchecked s in
               if not (Equality.is_equal_ty (Tm.ty t) asub) then
                 raise
                   (NotEqual
                      ( Printing.ty_to_string (Tm.ty t),
                        Printing.ty_to_string asub ));
 
-              t :: sub.list
+              t :: sub_checked
         in
-        { list = expr s tgt; src; tgt; unchecked = s }
+        { list = list s tgt.c; src; tgt; unchecked = s }
       in
       aux src s tgt
-
-    let forget s = s.unchecked
   end
 
   (** A context, associating a type to each context variable. *)
   and Ctx : sig
-    type t
+    type t = private { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
 
     val empty : unit -> t
-    val tail : t -> t
     val to_string : t -> string
     val ty_var : t -> Var.t -> Ty.t
     val domain : t -> Var.t list
-    val value : t -> (Var.t * Ty.t) list
     val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
     val forget : t -> (Coh.t, Tm.t) ctx
     val check : (Coh.t, Tm.t) ctx -> t
@@ -94,29 +79,16 @@ module Make (Core : Core.S) = struct
   end = struct
     type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
 
-    module Core = struct
-      module PS = PS
-      module Coh = Coh
-      module Tm = Tm
-    end
-
     open Syntax.Make (Core)
 
     let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
-    let tail ctx =
-      match (ctx.c, ctx.unchecked) with
-      | [], (_ :: _ | []) -> Error.fatal "computing tail of an empty context"
-      | _ :: _, [] -> Error.fatal "safe and unchecked context out of sync"
-      | _ :: c, _ :: unchecked -> { c; unchecked }
-
     let ty_var ctx x =
       try List.assoc x ctx.c
       with Not_found -> raise (Error.UnknownId (Var.to_string x))
 
     let empty () = { c = []; unchecked = [] }
     let domain ctx = List.map fst ctx.c
-    let value ctx = ctx.c
     let forget c = c.unchecked
     let to_string ctx = Printing.ctx_to_string (forget ctx)
 
@@ -139,10 +111,7 @@ module Make (Core : Core.S) = struct
     let extend ctx ~expl x t =
       let ty = Ty.check ctx t in
       Ctx.check_notin ctx x;
-      {
-        c = (x, ty) :: Ctx.value ctx;
-        unchecked = (x, (t, expl)) :: Ctx.forget ctx;
-      }
+      { c = (x, ty) :: ctx.c; unchecked = (x, (t, expl)) :: Ctx.forget ctx }
 
     let check c =
       match Hashtbl.find_opt tbl c with
@@ -158,29 +127,18 @@ module Make (Core : Core.S) = struct
   end
 
   and Ty : sig
-    type t
+    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
+    and expr = Obj | Arr of t * Tm.t * Tm.t
 
     val to_string : t -> string
-    val is_obj : t -> bool
     val is_equal : t -> t -> bool
     val check_equal : t -> t -> unit
     val morphism : Tm.t -> Tm.t -> Ty.t
-    val forget : t -> (Coh.t, Tm.t) ty
     val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
     val apply_sub : t -> Sub.t -> t
-    val retrieve_arrow : t -> Tm.t * Tm.t
-    val under_type : t -> t
-    val source : t -> Tm.t
-    val target : t -> Tm.t
     val ctx : t -> Ctx.t
     val dim : t -> int
   end = struct
-    module Core = struct
-      module PS = PS
-      module Coh = Coh
-      module Tm = Tm
-    end
-
     open Syntax.Make (Core)
 
     (** A type exepression. *)
@@ -189,20 +147,6 @@ module Make (Core : Core.S) = struct
     and t = { c : Ctx.t; e : expr; unchecked : ty }
 
     let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
-    let is_obj t = t.e = Obj
-
-    let retrieve_arrow ty =
-      match ty.e with
-      | Obj ->
-          Error.fatal
-            "calling source and target on a type that is not an arrow type"
-      | Arr (_, u, v) -> (u, v)
-
-    let under_type ty =
-      match ty.e with Obj -> raise IsObj | Arr (a, _, _) -> a
-
-    let source ty = match ty.e with Obj -> raise IsObj | Arr (_, u, _) -> u
-    let target ty = match ty.e with Obj -> raise IsObj | Arr (_, _, v) -> v
 
     let rec check c t =
       Io.info ~v:5
@@ -226,18 +170,18 @@ module Make (Core : Core.S) = struct
           Hashtbl.add tbl (c, t) ty;
           ty
 
-    let forget t = t.unchecked
-    let to_string ty = Printing.ty_to_string (forget ty)
+    let to_string ty = Printing.ty_to_string ty.unchecked
 
     let is_equal ty1 ty2 =
-      Ctx.is_equal ty1.c ty2.c && Equality.is_equal_ty (forget ty1) (forget ty2)
+      Ctx.is_equal ty1.c ty2.c
+      && Equality.is_equal_ty ty1.unchecked ty2.unchecked
 
     let check_equal ty1 ty2 =
       if not (is_equal ty1 ty2) then
         raise
           (NotEqual
-             ( Printing.ty_to_string (forget ty1),
-               Printing.ty_to_string (forget ty2) ))
+             ( Printing.ty_to_string ty1.unchecked,
+               Printing.ty_to_string ty2.unchecked ))
 
     let morphism t1 t2 =
       let a = Tm.ty t1 in
@@ -257,9 +201,9 @@ module Make (Core : Core.S) = struct
         unchecked = Arr (a, Tm.forget t1, Tm.forget t2);
       }
 
-    let apply_sub t s =
-      Ctx.check_equal t.c (Sub.tgt s);
-      check (Sub.src s) (Unchecked.ty_apply_sub (forget t) (Sub.forget s))
+    let apply_sub t (s : Sub.t) =
+      Ctx.check_equal t.c s.tgt;
+      check s.src (Unchecked.ty_apply_sub t.unchecked s.unchecked)
 
     let ctx t = t.c
     let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
diff --git a/lib/internals/fullness.ml b/lib/internals/fullness.ml
index 1637b8e3..d6b9396a 100644
--- a/lib/internals/fullness.ml
+++ b/lib/internals/fullness.ml
@@ -1,49 +1,108 @@
+open Std
 open Common
 
-module Make
-    (Theory : Theory.S)
-    (Sub : sig
-      type t
-    end)
-    (PS : sig
-      type t
-
-      val source : t -> Sub.t
-      val target : t -> Sub.t
-    end)
-    (Tm : sig
-      type t
-
-      val preimage : t -> Sub.t -> t
-      val contains_all_vars : t -> bool
-    end)
-    (Ty : sig
-      type t
-
-      val dim : t -> int
-      val retrieve_arrow : t -> Tm.t * Tm.t
-      val contains_all_vars : t -> bool
-    end) =
-struct
+module type FArgs = sig
+  module Theory : Theory.S
+
+  module Coh : sig
+    type t
+  end
+
+  module Ctx : sig
+    type t
+
+    val domain : t -> Var.t list
+  end
+
+  module rec Sub : sig
+    type t = private {
+      list : Tm.t list;
+      src : Ctx.t;
+      tgt : Ctx.t;
+      unchecked : (Coh.t, Tm.t) sub;
+    }
+  end
+
+  and Ty : sig
+    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
+    and expr = Obj | Arr of t * Tm.t * Tm.t
+
+    val dim : t -> int
+  end
+
+  and Tm : sig
+    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
+
+    and t = private {
+      ty : Ty.t;
+      e : expr;
+      unchecked : (Coh.t, t) tm;
+      mutable developped : (Coh.t, t) tm option;
+      name : pp_data option;
+    }
+
+    val preimage : t -> Sub.t -> t
+  end
+
+  module PS : sig
+    type t
+
+    val source : t -> Sub.t
+    val target : t -> Sub.t
+  end
+end
+
+module Make (A : FArgs) = struct
+  open A
+
   type res = Inv | NonInv of Tm.t * Tm.t | No
 
+  let rec tm_free_vars (tm : Tm.t) =
+    let fvty = ty_free_vars tm.ty in
+    match tm.e with
+    | Var x -> x :: fvty
+    | Coh (_, sub) | App (_, sub) -> sub_free_vars sub
+
+  and ty_free_vars (ty : Ty.t) =
+    match ty.e with
+    | Obj -> []
+    | Arr (t, u, v) ->
+        List.unions [ ty_free_vars t; tm_free_vars u; tm_free_vars v ]
+
+  and sub_free_vars (s : Sub.t) = List.concat (List.map tm_free_vars s.list)
+
+  let ty_contains_all_vars (t : Ty.t) =
+    List.included (Ctx.domain t.c) (ty_free_vars t)
+
+  let tm_contains_all_vars (t : Tm.t) =
+    List.included (Ctx.domain t.ty.c) (tm_free_vars t)
+
+  let is_inv_dim t =
+    match Theory.theory.invertibility with
+    | None -> false
+    | Some d when d >= Ty.dim t -> false
+    | _ -> true
+
+  let check_full_inv t =
+    if is_inv_dim t || ty_contains_all_vars t then Inv else No
+
+  let check_full_noninv ps (t : Ty.t) =
+    match t.e with
+    | Obj -> No
+    | Arr (_, src, tgt) -> (
+        try
+          let src_inclusion = PS.source ps in
+          let src = Tm.preimage src src_inclusion in
+          if not (tm_contains_all_vars src) then No
+          else
+            let tgt_inclusion = PS.target ps in
+            let tgt = Tm.preimage tgt tgt_inclusion in
+            if not (tm_contains_all_vars tgt) then No else NonInv (src, tgt)
+        with NotInImage -> No)
+
   let check ps t =
-    let needs_check =
-      match Theory.theory.invertibility with
-      | None -> true
-      | Some d when d >= Ty.dim t -> true
-      | _ -> false
-    in
-    if (not needs_check) || Ty.contains_all_vars t then Inv
-    else
-      try
-        let src, tgt = Ty.retrieve_arrow t in
-        let src_inclusion = PS.source ps in
-        let src = Tm.preimage src src_inclusion in
-        if not (Tm.contains_all_vars src) then No
-        else
-          let tgt_inclusion = PS.target ps in
-          let tgt = Tm.preimage tgt tgt_inclusion in
-          if not (Tm.contains_all_vars tgt) then No else NonInv (src, tgt)
-      with NotInImage -> No
+    match check_full_inv t with
+    | Inv -> Inv
+    | NonInv _ -> assert false
+    | No -> check_full_noninv ps t
 end
diff --git a/lib/internals/fullness.mli b/lib/internals/fullness.mli
index 91c23356..d42cba4f 100644
--- a/lib/internals/fullness.mli
+++ b/lib/internals/fullness.mli
@@ -1,28 +1,59 @@
-module Make : functor
-  (_ : Theory.S)
-  (Sub : sig
-     type t
-   end)
-  (PS : sig
-     type t
-
-     val source : t -> Sub.t
-     val target : t -> Sub.t
-   end)
-  (Tm : sig
-     type t
-
-     val preimage : t -> Sub.t -> t
-     val contains_all_vars : t -> bool
-   end)
-  (Ty : sig
-     type t
-
-     val dim : t -> int
-     val retrieve_arrow : t -> Tm.t * Tm.t
-     val contains_all_vars : t -> bool
-   end)
-  -> sig
+open Common
+
+module type FArgs = sig
+  module Theory : Theory.S
+
+  module Coh : sig
+    type t
+  end
+
+  module Ctx : sig
+    type t
+
+    val domain : t -> Var.t list
+  end
+
+  module rec Sub : sig
+    type t = private {
+      list : Tm.t list;
+      src : Ctx.t;
+      tgt : Ctx.t;
+      unchecked : (Coh.t, Tm.t) sub;
+    }
+  end
+
+  and Ty : sig
+    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
+    and expr = Obj | Arr of t * Tm.t * Tm.t
+
+    val dim : t -> int
+  end
+
+  and Tm : sig
+    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
+
+    and t = private {
+      ty : Ty.t;
+      e : expr;
+      unchecked : (Coh.t, t) tm;
+      mutable developped : (Coh.t, t) tm option;
+      name : pp_data option;
+    }
+
+    val preimage : t -> Sub.t -> t
+  end
+
+  module PS : sig
+    type t
+
+    val source : t -> Sub.t
+    val target : t -> Sub.t
+  end
+end
+
+module Make : functor (A : FArgs) -> sig
+  open A
+
   type res = Inv | NonInv of Tm.t * Tm.t | No
 
   val check : PS.t -> Ty.t -> res
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index 33c2796c..068b24f9 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -3,6 +3,7 @@ open Common
 module CoreSignature = Core
 
 exception IsCoh
+exception IsObj
 exception MetaVariable
 
 module Make (Theory : Theory.S) = struct
@@ -12,57 +13,36 @@ module Make (Theory : Theory.S) = struct
 
     val check : B.Ctx.t -> (Coh.t, Tm.t) sub -> B.Ctx.t -> B.Sub.t
     val check_to_ps : B.Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> B.Sub.t
-    val forget : B.Sub.t -> (Coh.t, Tm.t) sub
-    val free_vars : B.Sub.t -> Var.t list
-    val src : B.Sub.t -> B.Ctx.t
-    val tgt : B.Sub.t -> B.Ctx.t
   end = struct
     include B.Sub
 
-    let free_vars s = List.concat (List.map Tm.free_vars (to_list s))
-
-    let check_to_ps src s tgt_ps =
-      let tgt = PS.to_ctx tgt_ps in
+    let check_to_ps src s (tgt_ps : PS.t) =
+      let tgt = tgt_ps.ctx in
       let s_assoc =
-        try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) (Ctx.value tgt) s
+        try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) tgt.c s
         with Invalid_argument _ ->
           Error.fatal "uncaught wrong number of arguments"
       in
       check src s_assoc tgt
   end
 
-  (** A context, associating a type to each context variable. *)
-  and Ctx : sig
-    type t = B.Ctx.t
-
-    val to_string : t -> string
-    val ty_var : t -> Var.t -> B.Ty.t
-    val domain : t -> Var.t list
-    val value : t -> (Var.t * B.Ty.t) list
-    val forget : t -> (Coh.t, Tm.t) ctx
-    val check : (Coh.t, Tm.t) ctx -> t
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-  end =
-    B.Ctx
-
   (** Operations on pasting schemes. *)
   and PS : sig
     exception Invalid
 
-    type t
+    type t = private { tree : ps; ctx : B.Ctx.t }
 
     val to_string : t -> string
-    val mk : Ctx.t -> t
-    val to_ctx : t -> Ctx.t
+    val mk : B.Ctx.t -> t
     val bdry : t -> t
     val source : t -> B.Sub.t
     val target : t -> B.Sub.t
-    val forget : t -> ps
     val is_equal : t -> t -> bool
   end = struct
     exception Invalid
 
+    module Ctx = B.Ctx
+    module Ty = B.Ty
     open Syntax.Make (Core)
 
     (** A pasting scheme. *)
@@ -81,8 +61,8 @@ module Make (Theory : Theory.S) = struct
         match ps with
         | PDrop ps -> list ps
         | PCons (ps, (x1, t1), (x2, t2)) ->
-            (x2, (Ty.forget t2, true)) :: (x1, (Ty.forget t1, true)) :: list ps
-        | PNil (x, t) -> [ (x, (Ty.forget t, true)) ]
+            (x2, (t2.unchecked, true)) :: (x1, (t1.unchecked, true)) :: list ps
+        | PNil (x, t) -> [ (x, (t.unchecked, true)) ]
       in
       Ctx.check (list ps)
 
@@ -93,7 +73,7 @@ module Make (Theory : Theory.S) = struct
       | PCons (_, _, f) -> f
       | PDrop ps ->
           let _, tf = marker ps in
-          let v = try Ty.target tf with B.IsObj -> raise Invalid in
+          let v = match tf.e with Obj -> raise Invalid | Arr (_, _, v) -> v in
           let y = try Tm.to_var v with B.IsCoh -> raise Invalid in
           let t =
             let rec aux = function
@@ -110,23 +90,18 @@ module Make (Theory : Theory.S) = struct
 
     (** Create a pasting scheme from a context. *)
     let make_old (l : Ctx.t) =
-      let rec close ps tx =
-        if Ty.is_obj tx then ps
-        else
-          let tx = Ty.under_type tx in
-          close (PDrop ps) tx
+      let rec close ps (tx : Ty.t) =
+        match tx.e with Obj -> ps | Arr (tx, _, _) -> close (PDrop ps) tx
       in
       let build l =
         let x0, ty, l =
-          match l with
-          | (x, ty) :: l when Ty.is_obj ty -> (x, ty, l)
+          match (l : (Var.t * Ty.t) list) with
+          | (x, ({ e = Obj; _ } as ty)) :: l -> (x, ty, l)
           | _ -> raise Invalid
         in
-        let rec aux ps = function
-          | (y, ty) :: (f, tf) :: l as l1 ->
-              let u, v =
-                try Ty.retrieve_arrow tf with B.IsObj -> raise Invalid
-              in
+        let rec aux ps (l : (Var.t * Ty.t) list) =
+          match l with
+          | (y, ty) :: (f, ({ e = Arr (_, u, v); _ } as tf)) :: l as l1 ->
               let fx, fy =
                 try (Tm.to_var u, Tm.to_var v) with B.IsCoh -> raise Invalid
               in
@@ -139,14 +114,14 @@ module Make (Theory : Theory.S) = struct
                 let ps = PCons (ps, (y, ty), (f, tf)) in
                 aux ps l)
               else aux (PDrop ps) l1
-          | [ (_, _) ] -> raise Invalid
+          | _ :: _ :: _ | [ (_, _) ] -> raise Invalid
           | [] ->
               let _, tx = marker ps in
               close ps tx
         in
         aux (PNil (x0, ty)) l
       in
-      build (List.rev (Ctx.value l))
+      build (List.rev l.c)
 
     (* assumes that all ps are completed with enough PDrop in the end *)
     let make_tree ps =
@@ -177,70 +152,33 @@ module Make (Theory : Theory.S) = struct
           Hashtbl.add tbl l ps;
           ps
 
-    let forget ps = ps.tree
-    let to_string ps = Printing.ps_to_string (forget ps)
-
-    (** Create a context from a pasting scheme. *)
-    let to_ctx ps = ps.ctx
+    let to_string ps = Printing.ps_to_string ps.tree
 
     let bdry ps =
       mk (Ctx.check (Unchecked.ps_to_ctx (Unchecked.ps_bdry ps.tree)))
 
-    let source ps =
-      Sub.check_to_ps (to_ctx ps) (Unchecked.ps_src ps.tree) (bdry ps)
-
-    let target ps =
-      Sub.check_to_ps (to_ctx ps) (Unchecked.ps_tgt ps.tree) (bdry ps)
+    let source ps = Sub.check_to_ps ps.ctx (Unchecked.ps_src ps.tree) (bdry ps)
+    let target ps = Sub.check_to_ps ps.ctx (Unchecked.ps_tgt ps.tree) (bdry ps)
 
     let is_equal ps1 ps2 =
       ps1.tree == ps2.tree || Equality.is_equal_ps ps1.tree ps2.tree
   end
 
-  and Ty : sig
-    type t = B.Ty.t
-
-    val to_string : t -> string
-    val free_vars : t -> Var.t list
-    val contains_all_vars : t -> bool
-    val is_full : t -> bool
-    val is_obj : t -> bool
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val morphism : Tm.t -> Tm.t -> t
-    val forget : t -> (Coh.t, Tm.t) ty
-    val check : B.Ctx.t -> (Coh.t, Tm.t) ty -> t
-    val apply_sub : t -> B.Sub.t -> t
-    val retrieve_arrow : t -> Tm.t * Tm.t
-    val under_type : t -> t
-    val source : t -> Tm.t
-    val target : t -> Tm.t
-    val ctx : t -> B.Ctx.t
-    val dim : t -> int
-  end = struct
-    include B.Ty
-
-    let rec free_vars (ty : t) =
-      if Ty.is_obj ty then []
-      else
-        let t, u, v = (Ty.under_type ty, Ty.source ty, Ty.target ty) in
-        List.unions [ free_vars t; Tm.free_vars u; Tm.free_vars v ]
-
-    (* TODO: remove is_full *)
-    let contains_all_vars (t : t) =
-      List.included (Ctx.domain (Ty.ctx t)) (free_vars t)
-
-    let is_full t = contains_all_vars t
-  end
-
   (** Operations on terms. *)
   and Tm : sig
-    type t
+    type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
+
+    and t = private {
+      ty : B.Ty.t;
+      e : expr;
+      unchecked : (Coh.t, t) tm;
+      mutable developped : (Coh.t, t) tm option;
+      name : pp_data option;
+    }
 
     (* Data extraction *)
     val to_var : t -> Var.t
-    val typ : t -> Ty.t
     val ty : t -> (Coh.t, Tm.t) ty
-    val bdry : t -> t * t
     val ctx : t -> (Coh.t, Tm.t) ctx
     val forget : t -> (Coh.t, Tm.t) tm
     val constr : t -> (Coh.t, Tm.t) constr
@@ -250,16 +188,11 @@ module Make (Theory : Theory.S) = struct
     val pp_data : t -> pp_data option
     val to_string : t -> string
 
-    (* Variable uses *)
-    val free_vars : t -> Var.t list
-    val contains_all_vars : t -> bool
-    val is_full : t -> bool
-
     (* Production of terms *)
     val of_coh : Coh.t -> t
 
     val check_in_ctx :
-      Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
+      B.Ctx.t -> ?ty:B.Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
 
     val check :
       (Coh.t, Tm.t) ctx ->
@@ -282,10 +215,12 @@ module Make (Theory : Theory.S) = struct
     val is_equal : t -> t -> bool
   end = struct
     open Syntax.Make (Core)
+    module Ty = B.Ty
+    module Ctx = B.Ctx
 
     type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
 
-    and t = {
+    type t = {
       ty : Ty.t;
       e : expr;
       unchecked : tm;
@@ -293,21 +228,8 @@ module Make (Theory : Theory.S) = struct
       name : pp_data option;
     }
 
-    let typ t = t.ty
-    let ty t = Ty.forget t.ty
-    let tbl : (Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
-
-    let free_vars tm =
-      let fvty = Ty.free_vars tm.ty in
-      match tm.e with
-      | Var x -> x :: fvty
-      | Coh (_, sub) | App (_, sub) -> Sub.free_vars sub
-
-    (* TODO: remove is_full *)
-    let contains_all_vars tm =
-      List.included (Ctx.domain (Ty.ctx tm.ty)) (free_vars tm)
-
-    let is_full tm = contains_all_vars tm
+    let ty t = t.ty.unchecked
+    let tbl : (B.Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
     let forget tm = tm.unchecked
     let constr tm = (forget tm, ty tm)
 
@@ -322,7 +244,7 @@ module Make (Theory : Theory.S) = struct
         | None -> (
             match t with
             | Var x ->
-                let e, ty = (Var x, Ty.check c (Ty.forget (Ctx.ty_var c x))) in
+                let e, ty = (Var x, Ty.check c (Ctx.ty_var c x).unchecked) in
                 { ty; e; unchecked = t; developped = Some t; name }
             | Meta_tm _ -> raise MetaVariable
             | Coh (coh, s) ->
@@ -332,8 +254,8 @@ module Make (Theory : Theory.S) = struct
                 Hashtbl.add tbl (c, t) tm;
                 tm
             | App (u, s) ->
-                let ty = Tm.typ u in
-                let sub = Sub.check c s (Ty.ctx ty) in
+                let ty = u.ty in
+                let sub = Sub.check c s ty.c in
                 let e, ty = (App (u, sub), Ty.apply_sub ty sub) in
                 let tm = { ty; e; unchecked = t; developped = None; name } in
                 Hashtbl.add tbl (c, t) tm;
@@ -359,7 +281,7 @@ module Make (Theory : Theory.S) = struct
             | Var _ | Coh (_, _) -> tm.unchecked
             | App (t, s) ->
                 let dt = Tm.develop t in
-                let s = Sub.forget s in
+                let s = s.unchecked in
                 Unchecked.tm_apply_sub dt s
           in
           tm.developped <- Some dev;
@@ -375,25 +297,25 @@ module Make (Theory : Theory.S) = struct
           | Coh _ -> raise IsCoh
           | App _ | Meta_tm _ -> assert false)
 
-    let apply_sub t sub =
-      Ctx.check_equal (Sub.tgt sub) (Ty.ctx t.ty);
-      let c = Sub.src sub in
+    let apply_sub t (sub : B.Sub.t) =
+      Ctx.check_equal sub.tgt t.ty.c;
+      let c = sub.src in
       let ty = Ty.apply_sub t.ty sub in
-      let t = Unchecked.tm_apply_sub (forget t) (Sub.forget sub) in
+      let t = Unchecked.tm_apply_sub (forget t) sub.unchecked in
       check_in_ctx c ~ty t
 
-    let preimage t sub =
-      Ctx.check_equal (Sub.src sub) (Ty.ctx t.ty);
-      let c = Sub.tgt sub in
-      let t = Unchecked.tm_sub_preimage (forget t) (Sub.forget sub) in
+    let preimage t (sub : B.Sub.t) =
+      Ctx.check_equal sub.src t.ty.c;
+      let c = sub.tgt in
+      let t = Unchecked.tm_sub_preimage (forget t) sub.unchecked in
       check_in_ctx c t
 
     let is_equal t1 t2 =
-      Ctx.is_equal (Ty.ctx t1.ty) (Ty.ctx t2.ty)
+      Ctx.is_equal t1.ty.c t2.ty.c
       && Equality.is_equal_tm t1.unchecked t2.unchecked
 
     let apply fun_ctx fun_tm fun_pp_data tm =
-      let c = fun_ctx (Ctx.forget (Ty.ctx (typ tm))) in
+      let c = fun_ctx (Ctx.forget tm.ty.c) in
       let db_sub = Unchecked.db_level_sub_inv c in
       let c, _, _ = Unchecked.db_levels c in
       let c = Ctx.check c in
@@ -406,8 +328,7 @@ module Make (Theory : Theory.S) = struct
       in
       (check_in_ctx c ?name newexp, db_sub)
 
-    let bdry t = (Ty.source (typ t), Ty.target (typ t))
-    let ctx t = Ctx.forget (Ty.ctx (typ t))
+    let ctx t = Ctx.forget t.ty.c
     let name t = Option.map Printing.pp_data_to_string t.name
     let full_name t = Option.map Printing.full_name t.name
     let func_data t = Option.map (fun (_, _, f) -> f) t.name
@@ -431,7 +352,7 @@ module Make (Theory : Theory.S) = struct
     type innertm = Tm.t
 
     val ps : t -> PS.t
-    val ty : t -> Ty.t
+    val ty : t -> B.Ty.t
     val src : t -> (t, Tm.t) tm
     val tgt : t -> (t, Tm.t) tm
     val suspend : t -> t
@@ -461,6 +382,8 @@ module Make (Theory : Theory.S) = struct
       t ->
       t * (t, Tm.t) sub
   end = struct
+    module Ty = B.Ty
+
     type innertm = Tm.t
     type cohInv = { ps : PS.t; ty : Ty.t }
     type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
@@ -472,6 +395,19 @@ module Make (Theory : Theory.S) = struct
     let tbl_inv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
     let tbl_noninv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
 
+    module A = struct
+      module Theory = Theory
+      module PS = PS
+      module Sub = B.Sub
+      module Coh = Coh
+      module Tm = Tm
+      module Ctx = B.Ctx
+      module Ty = B.Ty
+    end
+
+    module Fullness = Fullness.Make (A)
+    module Ctx = B.Ctx
+
     exception NotAlgebraic
 
     let ps = function Inv (data, _) -> data.ps | NonInv (data, _) -> data.ps
@@ -480,22 +416,40 @@ module Make (Theory : Theory.S) = struct
       | Inv (data, _) -> data.ty
       | NonInv (data, _) -> data.total_ty
 
-    let src c = Tm.forget (Ty.source (ty c))
-    let tgt c = Tm.forget (Ty.target (ty c))
+    let src c =
+      match (ty c).e with Obj -> raise IsObj | Arr (_, s, _) -> Tm.forget s
+
+    let tgt c =
+      match (ty c).e with Obj -> raise IsObj | Arr (_, _, t) -> Tm.forget t
+
     let is_inv = function Inv (_, _) -> true | NonInv (_, _) -> false
 
     let algebraic ps ty name =
-      let module Fullness = Fullness.Make (Theory) (Sub) (PS) (Tm) (Ty) in
       match Fullness.check ps ty with
       | Inv ->
-          Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
+          Ctx.check_equal ps.ctx ty.c;
           Inv ({ ps; ty }, name)
       | NonInv (src, tgt) ->
-          Ctx.check_equal (PS.to_ctx ps) (Ty.ctx ty);
+          Ctx.check_equal ps.ctx ty.c;
           NonInv ({ ps; src; tgt; total_ty = ty }, name)
       | No -> raise NotAlgebraic
 
-    let check ps_unchkd t_unchkd ((name, _, _) as pp_data) =
+    let register ps t ((name, _, _) as pp_data) =
+      try
+        let coh = algebraic ps t pp_data in
+        Hashtbl.add tbl (ps.tree, t.unchecked) coh;
+        coh
+      with
+      | NotAlgebraic ->
+          Error.not_valid_coherence name
+            (Printf.sprintf "type %s not algebraic in pasting scheme %s"
+               (Printing.ty_to_string t.unchecked)
+               (Printing.ctx_to_string (Unchecked.ps_to_ctx ps.tree)))
+      | DoubledVar s ->
+          Error.not_valid_coherence name
+            (Printf.sprintf "variable %s appears twice in the context" s)
+
+    let check ps_unchkd t_unchkd name =
       Io.info ~v:5
         (lazy
           (Printf.sprintf "checking coherence (%s,%s)"
@@ -503,23 +457,11 @@ module Make (Theory : Theory.S) = struct
              (Printing.ty_to_string t_unchkd)));
       match Hashtbl.find_opt tbl (ps_unchkd, t_unchkd) with
       | Some coh -> coh
-      | None -> (
-          try
-            let cps = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
-            let ps = PS.mk cps in
-            let t = Ty.check cps t_unchkd in
-            let coh = algebraic ps t pp_data in
-            Hashtbl.add tbl (ps_unchkd, t_unchkd) coh;
-            coh
-          with
-          | NotAlgebraic ->
-              Error.not_valid_coherence name
-                (Printf.sprintf "type %s not algebraic in pasting scheme %s"
-                   (Printing.ty_to_string t_unchkd)
-                   (Printing.ctx_to_string (Unchecked.ps_to_ctx ps_unchkd)))
-          | DoubledVar s ->
-              Error.not_valid_coherence name
-                (Printf.sprintf "variable %s appears twice in the context" s))
+      | None ->
+          let cps = Ctx.check (Unchecked.ps_to_ctx ps_unchkd) in
+          let ps = PS.mk cps in
+          let t = Ty.check cps t_unchkd in
+          register ps t name
 
     let check_noninv ps_unchkd src_unchkd tgt_unchkd name =
       match Hashtbl.find_opt tbl_noninv (ps_unchkd, src_unchkd, tgt_unchkd) with
@@ -529,21 +471,14 @@ module Make (Theory : Theory.S) = struct
           let src_inclusion = PS.source ps in
           let tgt_inclusion = PS.target ps in
           let bdry = PS.bdry ps in
-          let cbdry = PS.to_ctx bdry in
-          let src = Tm.check_in_ctx cbdry src_unchkd in
-          if not (Tm.is_full src) then raise NotAlgebraic
-          else
-            let tgt = Tm.check_in_ctx cbdry tgt_unchkd in
-            if not (Tm.is_full tgt) then raise NotAlgebraic
-            else
-              let total_ty =
-                Ty.morphism
-                  (Tm.apply_sub src src_inclusion)
-                  (Tm.apply_sub tgt tgt_inclusion)
-              in
-              let coh = NonInv ({ ps; src; tgt; total_ty }, name) in
-              Hashtbl.add tbl_noninv (ps_unchkd, src_unchkd, tgt_unchkd) coh;
-              coh
+          let src = Tm.check_in_ctx bdry.ctx src_unchkd in
+          let tgt = Tm.check_in_ctx bdry.ctx tgt_unchkd in
+          let total_ty =
+            Ty.morphism
+              (Tm.apply_sub src src_inclusion)
+              (Tm.apply_sub tgt tgt_inclusion)
+          in
+          register ps total_ty name
 
     let check_inv ps_unchkd src_unchkd tgt_unchkd name =
       match Hashtbl.find_opt tbl_inv (ps_unchkd, src_unchkd, tgt_unchkd) with
@@ -554,11 +489,7 @@ module Make (Theory : Theory.S) = struct
           let src = Tm.check_in_ctx ctx src_unchkd in
           let tgt = Tm.check_in_ctx ctx tgt_unchkd in
           let ty = Ty.morphism src tgt in
-          if Ty.is_full ty then (
-            let coh = Inv ({ ps; ty }, name) in
-            Hashtbl.add tbl_inv (ps_unchkd, src_unchkd, tgt_unchkd) coh;
-            coh)
-          else raise NotAlgebraic
+          register ps ty name
 
     let data c =
       match c with
@@ -574,8 +505,7 @@ module Make (Theory : Theory.S) = struct
     let noninv_srctgt c =
       match c with
       | Inv (_, _) -> Error.fatal "non-invertible data of an invertible coh"
-      | NonInv (d, _) ->
-          (Tm.forget d.src, Tm.forget d.tgt, Ty.forget (Tm.typ d.src))
+      | NonInv (d, _) -> (Tm.forget d.src, Tm.forget d.tgt, d.src.ty.unchecked)
 
     let dim c =
       let ty =
@@ -588,7 +518,7 @@ module Make (Theory : Theory.S) = struct
 
     let forget c =
       let ps, ty, pp_data = data c in
-      (PS.forget ps, Ty.forget ty, pp_data)
+      (ps.tree, ty.unchecked, pp_data)
 
     let is_equal coh1 coh2 =
       coh1 == coh2
@@ -619,7 +549,7 @@ module Make (Theory : Theory.S) = struct
     let apply fun_ctx fun_ty fun_pp_data coh =
       let ps, ty, pp = forget coh in
       let ctx = fun_ctx (Unchecked.ps_to_ctx ps) in
-      let ps = PS.forget (PS.mk (Ctx.check ctx)) in
+      let ps = (PS.mk (Ctx.check ctx)).tree in
       let db_sub = Unchecked.db_level_sub_inv ctx in
       let pp_data = Display_maps.pp_data_rename (fun_pp_data pp) db_sub in
       let ty = Unchecked.ty_apply_sub (fun_ty ty) db_sub in
@@ -630,6 +560,7 @@ module Make (Theory : Theory.S) = struct
     (CoreSignature.S
       with type PS.t = PS.t
       with type Coh.t = Coh.t
+      with type Coh.innertm = Tm.t
       with type Tm.t = Tm.t) = struct
     module PS = PS
     module Tm = Tm
@@ -643,22 +574,25 @@ module Make (Theory : Theory.S) = struct
     exception MetaVariable
 
     module rec Sub : sig
-      type t
+      type t = private {
+        list : Tm.t list;
+        src : Ctx.t;
+        tgt : Ctx.t;
+        unchecked : (Coh.t, Tm.t) sub;
+      }
 
-      val to_list : t -> Tm.t list
       val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
-      val forget : t -> (Coh.t, Tm.t) sub
-      val src : t -> Ctx.t
-      val tgt : t -> Ctx.t
     end
 
     and Ctx : sig
-      type t
+      type t = private {
+        c : (Var.t * Ty.t) list;
+        unchecked : (Coh.t, Tm.t) ctx;
+      }
 
       val to_string : t -> string
       val ty_var : t -> Var.t -> Ty.t
       val domain : t -> Var.t list
-      val value : t -> (Var.t * Ty.t) list
       val forget : t -> (Coh.t, Tm.t) ctx
       val check : (Coh.t, Tm.t) ctx -> t
       val is_equal : t -> t -> bool
@@ -666,26 +600,22 @@ module Make (Theory : Theory.S) = struct
     end
 
     and Ty : sig
-      type t
+      type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
+      and expr = Obj | Arr of t * Tm.t * Tm.t
 
       val to_string : t -> string
-      val is_obj : t -> bool
       val is_equal : t -> t -> bool
       val check_equal : t -> t -> unit
       val morphism : Tm.t -> Tm.t -> Ty.t
-      val forget : t -> (Coh.t, Tm.t) ty
       val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
       val apply_sub : t -> Sub.t -> t
-      val retrieve_arrow : t -> Tm.t * Tm.t
-      val under_type : t -> t
-      val source : t -> Tm.t
-      val target : t -> Tm.t
-      val ctx : t -> Ctx.t
       val dim : t -> int
     end
   end =
     Builder.Make (Core)
 
+  module Ty = B.Ty
+  module Ctx = B.Ctx
   include Syntax.Make (Core)
 
   let check check_fn name =
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index aa3b22b5..01417636 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -42,19 +42,24 @@ module Make (_ : Theory.S) : sig
   end
 
   and Ty : sig
-    type t
-
-    val forget : t -> (Coh.t, Tm.t) ty
+    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
+    and expr = Obj | Arr of t * Tm.t * Tm.t
   end
 
   and Tm : sig
-    type t
+    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
+
+    and t = private {
+      ty : Ty.t;
+      e : expr;
+      unchecked : (Coh.t, t) tm;
+      mutable developped : (Coh.t, t) tm option;
+      name : pp_data option;
+    }
 
-    val typ : t -> Ty.t
     val ty : t -> (Coh.t, Tm.t) ty
     val forget : t -> (Coh.t, Tm.t) tm
     val constr : t -> (Coh.t, Tm.t) constr
-    val bdry : t -> t * t
     val ctx : t -> (Coh.t, Tm.t) ctx
     val name : t -> string option
     val full_name : t -> string option
@@ -76,7 +81,11 @@ module Make (_ : Theory.S) : sig
       t * (Coh.t, Tm.t) sub
   end
 
-  module Ctx : sig
+  and Sub : sig
+    type t
+  end
+
+  and Ctx : sig
     type t
 
     val check : (Coh.t, Tm.t) ctx -> t
@@ -85,10 +94,9 @@ module Make (_ : Theory.S) : sig
   module PS : sig
     exception Invalid
 
-    type t
+    type t = private { tree : ps; ctx : Ctx.t }
 
     val mk : Ctx.t -> t
-    val forget : t -> ps
   end
 
   module Core :
diff --git a/lib/lib/environments.ml b/lib/lib/environments.ml
index d685ebab..0b235afe 100644
--- a/lib/lib/environments.ml
+++ b/lib/lib/environments.ml
@@ -120,7 +120,7 @@ module Make (CurrentTheory : Theory.S) = struct
         let pp_data = (Var.to_string v, 0, []) in
         let kc = Ctx.check c in
         let tm = check_term kc ?ty ~name:pp_data t in
-        let ty = Ty.forget (Tm.typ tm) in
+        let ty = tm.ty.unchecked in
         let dim_input = Unchecked.dim_ctx c in
         let dim_output = Unchecked.dim_ty ty in
         Io.info ~v:4
diff --git a/lib/meta_operations/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
index a195dd45..56141964 100644
--- a/lib/meta_operations/cubical_composite.ml
+++ b/lib/meta_operations/cubical_composite.ml
@@ -384,7 +384,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     else
       let ps_f_c = F.ctx (Unchecked.ps_to_ctx ps) l_d0 in
       let _, names, _ = Unchecked.db_levels ps_f_c in
-      let ps_f = PS.(forget (mk (Ctx.check ps_f_c))) in
+      let ps_f = PS.((mk (Ctx.check ps_f_c)).tree) in
       let l_psf = List.map (fun x -> Var.Db (fst (List.assoc x names))) l_d1 in
       let names = List.map (fun (x, (n, e)) -> (Var.Db n, (Var x, e))) names in
       (ps_f, l_psf, names)
diff --git a/lib/meta_operations/functorialisation.ml b/lib/meta_operations/functorialisation.ml
index 5f0709c8..03f3670f 100644
--- a/lib/meta_operations/functorialisation.ml
+++ b/lib/meta_operations/functorialisation.ml
@@ -354,7 +354,7 @@ module Make (Theory : Theory.S) = struct
   let ps p l =
     let c = ctx (Unchecked.ps_to_ctx p) l in
     let _, names, _ = Unchecked.db_levels c in
-    (PS.(forget (mk (Ctx.check c))), names)
+    ((PS.mk (Ctx.check c)).tree, names)
 
   let sub_w_tgt p s l =
     let s_f = sub_ps s l in
diff --git a/lib/meta_operations/padding.ml b/lib/meta_operations/padding.ml
index 44ce628d..24a0fcc7 100644
--- a/lib/meta_operations/padding.ml
+++ b/lib/meta_operations/padding.ml
@@ -347,17 +347,23 @@ module Make (Theory : Theory.S) = struct
        enforce this more statically *)
       Construct.tm_app hex sub
 
-    let repad_one_step p_0 p_1 f q_0 q_1 g previous iota_minus iota_plus v sub =
-      let padding_0, padding_1 = Tm.bdry previous in
-      hexcomp (Tm.constr p_0) (Tm.constr p_1)
-        Construct.(apply_sub (tm_app_sub previous iota_minus) sub)
-        (Tm.constr f)
-        Construct.(tm_app_sub (Functorialisation.tm padding_0 [ (v, 1) ]) sub)
-        Construct.(tm_app_sub (Functorialisation.tm padding_1 [ (v, 1) ]) sub)
-        Construct.(
-          inverse (tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sub))
-        Construct.(apply_sub (tm_app_sub previous iota_plus) sub)
-        (Tm.constr q_0) (Tm.constr q_1) (Tm.constr g)
+    let repad_one_step p_0 p_1 f q_0 q_1 g (previous : Tm.t) iota_minus
+        iota_plus v sub =
+      match previous.ty.e with
+      | Obj -> assert false
+      | Arr (_, padding_0, padding_1) ->
+          hexcomp (Tm.constr p_0) (Tm.constr p_1)
+            Construct.(apply_sub (tm_app_sub previous iota_minus) sub)
+            (Tm.constr f)
+            Construct.(
+              tm_app_sub (Functorialisation.tm padding_0 [ (v, 1) ]) sub)
+            Construct.(
+              tm_app_sub (Functorialisation.tm padding_1 [ (v, 1) ]) sub)
+            Construct.(
+              inverse
+                (tm_app_sub (Functorialisation.tm previous [ (v, 1) ]) sub))
+            Construct.(apply_sub (tm_app_sub previous iota_plus) sub)
+            (Tm.constr q_0) (Tm.constr q_1) (Tm.constr g)
 
     module type RepaddingDataS = sig
       val f : int -> Tm.t

From ef7bfe2fa698accc6ccd8d54d2a9d45d8a5e6389 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Mon, 10 Nov 2025 15:23:47 +0100
Subject: [PATCH 27/30] more kernel cleanup

---
 lib/elaboration/elaborate.ml             |   2 +-
 lib/internals/builder.ml                 | 106 ++----
 lib/internals/core.mli                   |  13 +-
 lib/internals/kernel.ml                  | 402 +++++++++++++----------
 lib/internals/kernel.mli                 |  10 +-
 lib/meta_operations/cubical_composite.ml |   2 +-
 lib/meta_operations/functorialisation.ml |   2 +-
 7 files changed, 268 insertions(+), 269 deletions(-)

diff --git a/lib/elaboration/elaborate.ml b/lib/elaboration/elaborate.ml
index dc7c423d..de148e9c 100644
--- a/lib/elaboration/elaborate.ml
+++ b/lib/elaboration/elaborate.ml
@@ -362,7 +362,7 @@ module Make (Environment : Environments.S) = struct
       in
       try
         let _, names, _ = Unchecked.db_levels ps in
-        ((PS.mk (Ctx.check ps)).tree, Unchecked.rename_ty t names)
+        (PS.mk (Ctx.check ps), Unchecked.rename_ty t names)
       with
       | PS.Invalid -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
       | DoubledVar x -> raise (Error.doubled_var (Printing.ctx_to_string ps) x)
diff --git a/lib/internals/builder.ml b/lib/internals/builder.ml
index 28fe2749..c55dbbed 100644
--- a/lib/internals/builder.ml
+++ b/lib/internals/builder.ml
@@ -11,17 +11,22 @@ module Make (Core : Core.S) = struct
 
   (** Operations on substitutions. *)
   module rec Sub : sig
+    type expr = Tm.t list
+
     type t = private {
-      list : Tm.t list;
+      list : expr;
       src : Ctx.t;
       tgt : Ctx.t;
       unchecked : (Coh.t, Tm.t) sub;
     }
 
     val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
+    val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> Sub.t
   end = struct
+    type expr = Tm.t list
+
     type t = {
-      list : Tm.t list;
+      list : expr;
       src : Ctx.t;
       tgt : Ctx.t;
       unchecked : (Coh.t, Tm.t) sub;
@@ -48,7 +53,7 @@ module Make (Core : Core.S) = struct
           | (_, (t, _)) :: s, (_, a) :: tgt_tail ->
               let sub_checked = list s tgt_tail in
               let t = Tm.check (Ctx.forget src) t in
-              let asub = Unchecked.ty_apply_sub a.unchecked s in
+              let asub = Unchecked.ty_apply_sub (Ty.forget a) s in
               if not (Equality.is_equal_ty (Tm.ty t) asub) then
                 raise
                   (NotEqual
@@ -60,6 +65,15 @@ module Make (Core : Core.S) = struct
         { list = list s tgt.c; src; tgt; unchecked = s }
       in
       aux src s tgt
+
+    let check_to_ps src s (tgt_ps : PS.t) =
+      let tgt = Ctx.of_ps tgt_ps in
+      let s_assoc =
+        try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) tgt.c s
+        with Invalid_argument _ ->
+          Error.fatal "uncaught wrong number of arguments"
+      in
+      check src s_assoc tgt
   end
 
   (** A context, associating a type to each context variable. *)
@@ -76,6 +90,7 @@ module Make (Core : Core.S) = struct
     val check_notin : t -> Var.t -> unit
     val is_equal : t -> t -> bool
     val check_equal : t -> t -> unit
+    val of_ps : PS.t -> t
   end = struct
     type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
 
@@ -109,7 +124,7 @@ module Make (Core : Core.S) = struct
       with Not_found -> ()
 
     let extend ctx ~expl x t =
-      let ty = Ty.check ctx t in
+      let ty = Ty.check_with_ctx ctx.unchecked t in
       Ctx.check_notin ctx x;
       { c = (x, ty) :: ctx.c; unchecked = (x, (t, expl)) :: Ctx.forget ctx }
 
@@ -124,88 +139,7 @@ module Make (Core : Core.S) = struct
           in
           Hashtbl.add tbl c ctx;
           ctx
-  end
-
-  and Ty : sig
-    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val morphism : Tm.t -> Tm.t -> Ty.t
-    val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
-    val apply_sub : t -> Sub.t -> t
-    val ctx : t -> Ctx.t
-    val dim : t -> int
-  end = struct
-    open Syntax.Make (Core)
-
-    (** A type exepression. *)
-    type expr = Obj | Arr of t * Tm.t * Tm.t
 
-    and t = { c : Ctx.t; e : expr; unchecked : ty }
-
-    let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
-
-    let rec check c t =
-      Io.info ~v:5
-        (lazy
-          (Printf.sprintf "building kernel type %s in context %s"
-             (Printing.ty_to_string t) (Ctx.to_string c)));
-      match Hashtbl.find_opt tbl (c, t) with
-      | Some ty -> ty
-      | None ->
-          let e =
-            match t with
-            | Obj -> Obj
-            | Arr (a, u, v) ->
-                let achecked = check c a in
-                let u = Tm.check (Ctx.forget c) ~ty:a u in
-                let v = Tm.check (Ctx.forget c) ~ty:a v in
-                Arr (achecked, u, v)
-            | Meta_ty _ -> raise MetaVariable
-          in
-          let ty = { c; e; unchecked = t } in
-          Hashtbl.add tbl (c, t) ty;
-          ty
-
-    let to_string ty = Printing.ty_to_string ty.unchecked
-
-    let is_equal ty1 ty2 =
-      Ctx.is_equal ty1.c ty2.c
-      && Equality.is_equal_ty ty1.unchecked ty2.unchecked
-
-    let check_equal ty1 ty2 =
-      if not (is_equal ty1 ty2) then
-        raise
-          (NotEqual
-             ( Printing.ty_to_string ty1.unchecked,
-               Printing.ty_to_string ty2.unchecked ))
-
-    let morphism t1 t2 =
-      let a = Tm.ty t1 in
-      let c = Tm.ctx t1 in
-      if
-        not
-          (Equality.is_equal_ctx c (Tm.ctx t2)
-          && Equality.is_equal_ty a (Tm.ty t2))
-      then
-        raise
-          (NotEqual (Printing.ty_to_string a, Printing.ty_to_string (Tm.ty t2)));
-      let c = Ctx.check c in
-      let a_checked = check c a in
-      {
-        c;
-        e = Arr (a_checked, t1, t2);
-        unchecked = Arr (a, Tm.forget t1, Tm.forget t2);
-      }
-
-    let apply_sub t (s : Sub.t) =
-      Ctx.check_equal t.c s.tgt;
-      check s.src (Unchecked.ty_apply_sub t.unchecked s.unchecked)
-
-    let ctx t = t.c
-    let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
+    let of_ps ps = check (Unchecked.ps_to_ctx ps)
   end
 end
diff --git a/lib/internals/core.mli b/lib/internals/core.mli
index 45c78482..bc850ee6 100644
--- a/lib/internals/core.mli
+++ b/lib/internals/core.mli
@@ -2,7 +2,7 @@ open Common
 
 module type S = sig
   module PS : sig
-    type t
+    type t = ps
   end
 
   module Coh : sig
@@ -25,6 +25,7 @@ module type S = sig
     val full_name : t -> string option
     val ctx : t -> (Coh.t, t) ctx
     val is_equal : t -> t -> bool
+    val to_var : t -> Var.t
 
     val check :
       (Coh.t, t) ctx -> ?ty:(Coh.t, t) ty -> ?name:pp_data -> (Coh.t, t) tm -> t
@@ -39,4 +40,14 @@ module type S = sig
       t ->
       t * (Coh.t, t) sub
   end
+
+  module Ty : sig
+    type t
+
+    val to_string : t -> string
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val forget : t -> (Coh.t, Tm.t) ty
+    val check_with_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ty -> t
+  end
 end
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index 068b24f9..199df118 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -1,4 +1,3 @@
-open Std
 open Common
 module CoreSignature = Core
 
@@ -7,161 +6,89 @@ exception IsObj
 exception MetaVariable
 
 module Make (Theory : Theory.S) = struct
-  (** Operations on substitutions. *)
-  module rec Sub : sig
-    type t = B.Sub.t
-
-    val check : B.Ctx.t -> (Coh.t, Tm.t) sub -> B.Ctx.t -> B.Sub.t
-    val check_to_ps : B.Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> B.Sub.t
-  end = struct
-    include B.Sub
-
-    let check_to_ps src s (tgt_ps : PS.t) =
-      let tgt = tgt_ps.ctx in
-      let s_assoc =
-        try List.map2 (fun (x, _) (t, e) -> (x, (t, e))) tgt.c s
-        with Invalid_argument _ ->
-          Error.fatal "uncaught wrong number of arguments"
-      in
-      check src s_assoc tgt
-  end
-
-  (** Operations on pasting schemes. *)
-  and PS : sig
-    exception Invalid
-
-    type t = private { tree : ps; ctx : B.Ctx.t }
+  module rec Ty : sig
+    type t = private { c : B.Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
+    and expr = Obj | Arr of t * Tm.t * Tm.t
 
     val to_string : t -> string
-    val mk : B.Ctx.t -> t
-    val bdry : t -> t
-    val source : t -> B.Sub.t
-    val target : t -> B.Sub.t
     val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val morphism : Tm.t -> Tm.t -> Ty.t
+    val check : B.Ctx.t -> (Coh.t, Tm.t) ty -> t
+    val apply_sub : t -> B.Sub.t -> t
+    val dim : t -> int
+    val forget : t -> (Coh.t, Tm.t) ty
+    val check_with_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ty -> t
   end = struct
-    exception Invalid
-
     module Ctx = B.Ctx
-    module Ty = B.Ty
+    module Sub = B.Sub
     open Syntax.Make (Core)
 
-    (** A pasting scheme. *)
-    type ps_derivation =
-      | PNil of (Var.t * Ty.t)
-      | PCons of ps_derivation * (Var.t * Ty.t) * (Var.t * Ty.t)
-      | PDrop of ps_derivation
-
-    type t = { tree : ps; ctx : Ctx.t }
-
-    let tbl : (Ctx.t, PS.t) Hashtbl.t = Hashtbl.create 7829
-
-    (** Create a context from a pasting scheme. *)
-    let old_rep_to_ctx ps =
-      let rec list ps =
-        match ps with
-        | PDrop ps -> list ps
-        | PCons (ps, (x1, t1), (x2, t2)) ->
-            (x2, (t2.unchecked, true)) :: (x1, (t1.unchecked, true)) :: list ps
-        | PNil (x, t) -> [ (x, (t.unchecked, true)) ]
-      in
-      Ctx.check (list ps)
-
-    (** Dangling variable. *)
-    let rec marker (ps : ps_derivation) =
-      match ps with
-      | PNil (x, t) -> (x, t)
-      | PCons (_, _, f) -> f
-      | PDrop ps ->
-          let _, tf = marker ps in
-          let v = match tf.e with Obj -> raise Invalid | Arr (_, _, v) -> v in
-          let y = try Tm.to_var v with B.IsCoh -> raise Invalid in
-          let t =
-            let rec aux = function
-              | PNil (x, t) ->
-                  assert (x = y);
-                  t
-              | PCons (ps, (y', ty), (f, tf)) ->
-                  if y' = y then ty else if f = y then tf else aux ps
-              | PDrop ps -> aux ps
-            in
-            aux ps
-          in
-          (y, t)
-
-    (** Create a pasting scheme from a context. *)
-    let make_old (l : Ctx.t) =
-      let rec close ps (tx : Ty.t) =
-        match tx.e with Obj -> ps | Arr (tx, _, _) -> close (PDrop ps) tx
-      in
-      let build l =
-        let x0, ty, l =
-          match (l : (Var.t * Ty.t) list) with
-          | (x, ({ e = Obj; _ } as ty)) :: l -> (x, ty, l)
-          | _ -> raise Invalid
-        in
-        let rec aux ps (l : (Var.t * Ty.t) list) =
-          match l with
-          | (y, ty) :: (f, ({ e = Arr (_, u, v); _ } as tf)) :: l as l1 ->
-              let fx, fy =
-                try (Tm.to_var u, Tm.to_var v) with B.IsCoh -> raise Invalid
-              in
-              if y <> fy then raise Invalid;
-              let x, _ = marker ps in
-              if x = fx then (
-                let varps = Ctx.domain (old_rep_to_ctx ps) in
-                if List.mem f varps then raise (DoubledVar (Var.to_string f));
-                if List.mem y varps then raise (DoubledVar (Var.to_string y));
-                let ps = PCons (ps, (y, ty), (f, tf)) in
-                aux ps l)
-              else aux (PDrop ps) l1
-          | _ :: _ :: _ | [ (_, _) ] -> raise Invalid
-          | [] ->
-              let _, tx = marker ps in
-              close ps tx
-        in
-        aux (PNil (x0, ty)) l
-      in
-      build (List.rev l.c)
+    type expr = Obj | Arr of t * Tm.t * Tm.t  (** A type exepression. *)
+    and t = { c : B.Ctx.t; e : expr; unchecked : ty }
 
-    (* assumes that all ps are completed with enough PDrop in the end *)
-    let make_tree ps =
-      let rec find_previous ps list =
-        match ps with
-        | PNil x -> (Br list, PNil x)
-        | PCons (ps, _, _) -> (Br list, ps)
-        | PDrop _ as ps ->
-            let p, ps = build_till_previous ps in
-            (Br p, ps)
-      and build_till_previous ps =
-        match ps with
-        | PNil x -> ([], PNil x)
-        | PCons (ps, _, _) -> ([], ps)
-        | PDrop ps ->
-            let p, ps = find_previous ps [] in
-            let prev, ps = build_till_previous ps in
-            (p :: prev, ps)
-      in
-      Br (fst (build_till_previous ps))
+    let tbl : (B.Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
 
-    let mk (l : Ctx.t) =
-      match Hashtbl.find_opt tbl l with
-      | Some ps -> ps
+    let rec check c t =
+      Io.info ~v:5
+        (lazy
+          (Printf.sprintf "building kernel type %s in context %s"
+             (Printing.ty_to_string t) (Ctx.to_string c)));
+      match Hashtbl.find_opt tbl (c, t) with
+      | Some ty -> ty
       | None ->
-          let oldrep = make_old l in
-          let ps = { tree = make_tree oldrep; ctx = l } in
-          Hashtbl.add tbl l ps;
-          ps
-
-    let to_string ps = Printing.ps_to_string ps.tree
-
-    let bdry ps =
-      mk (Ctx.check (Unchecked.ps_to_ctx (Unchecked.ps_bdry ps.tree)))
+          let e =
+            match t with
+            | Obj -> Obj
+            | Arr (a, u, v) ->
+                let achecked = check c a in
+                let u = Tm.check (Ctx.forget c) ~ty:a u in
+                let v = Tm.check (Ctx.forget c) ~ty:a v in
+                Arr (achecked, u, v)
+            | Meta_ty _ -> raise MetaVariable
+          in
+          let ty = { c; e; unchecked = t } in
+          Hashtbl.add tbl (c, t) ty;
+          ty
+
+    let check_with_ctx ctx ty = check (Ctx.check ctx) ty
+    let to_string ty = Printing.ty_to_string ty.unchecked
+
+    let is_equal ty1 ty2 =
+      Ctx.is_equal ty1.c ty2.c
+      && Equality.is_equal_ty ty1.unchecked ty2.unchecked
+
+    let check_equal ty1 ty2 =
+      if not (is_equal ty1 ty2) then
+        raise
+          (NotEqual
+             ( Printing.ty_to_string ty1.unchecked,
+               Printing.ty_to_string ty2.unchecked ))
+
+    let morphism t1 t2 =
+      let a = Tm.ty t1 in
+      let c = Tm.ctx t1 in
+      if
+        not
+          (Equality.is_equal_ctx c (Tm.ctx t2)
+          && Equality.is_equal_ty a (Tm.ty t2))
+      then
+        raise
+          (NotEqual (Printing.ty_to_string a, Printing.ty_to_string (Tm.ty t2)));
+      let c = Ctx.check c in
+      let a_checked = check c a in
+      {
+        c;
+        e = Arr (a_checked, t1, t2);
+        unchecked = Arr (a, Tm.forget t1, Tm.forget t2);
+      }
 
-    let source ps = Sub.check_to_ps ps.ctx (Unchecked.ps_src ps.tree) (bdry ps)
-    let target ps = Sub.check_to_ps ps.ctx (Unchecked.ps_tgt ps.tree) (bdry ps)
+    let apply_sub t (s : Sub.t) =
+      Ctx.check_equal t.c s.tgt;
+      check s.src (Unchecked.ty_apply_sub t.unchecked s.unchecked)
 
-    let is_equal ps1 ps2 =
-      ps1.tree == ps2.tree || Equality.is_equal_ps ps1.tree ps2.tree
+    let rec dim t = match t.e with Obj -> 0 | Arr (a, _, _) -> 1 + dim a
+    let forget t = t.unchecked
   end
 
   (** Operations on terms. *)
@@ -169,7 +96,7 @@ module Make (Theory : Theory.S) = struct
     type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
 
     and t = private {
-      ty : B.Ty.t;
+      ty : Ty.t;
       e : expr;
       unchecked : (Coh.t, t) tm;
       mutable developped : (Coh.t, t) tm option;
@@ -192,7 +119,7 @@ module Make (Theory : Theory.S) = struct
     val of_coh : Coh.t -> t
 
     val check_in_ctx :
-      B.Ctx.t -> ?ty:B.Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
+      B.Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
 
     val check :
       (Coh.t, Tm.t) ctx ->
@@ -215,8 +142,8 @@ module Make (Theory : Theory.S) = struct
     val is_equal : t -> t -> bool
   end = struct
     open Syntax.Make (Core)
-    module Ty = B.Ty
     module Ctx = B.Ctx
+    module Sub = B.Sub
 
     type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
 
@@ -352,7 +279,7 @@ module Make (Theory : Theory.S) = struct
     type innertm = Tm.t
 
     val ps : t -> PS.t
-    val ty : t -> B.Ty.t
+    val ty : t -> Ty.t
     val src : t -> (t, Tm.t) tm
     val tgt : t -> (t, Tm.t) tm
     val suspend : t -> t
@@ -382,8 +309,6 @@ module Make (Theory : Theory.S) = struct
       t ->
       t * (t, Tm.t) sub
   end = struct
-    module Ty = B.Ty
-
     type innertm = Tm.t
     type cohInv = { ps : PS.t; ty : Ty.t }
     type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
@@ -402,7 +327,7 @@ module Make (Theory : Theory.S) = struct
       module Coh = Coh
       module Tm = Tm
       module Ctx = B.Ctx
-      module Ty = B.Ty
+      module Ty = Ty
     end
 
     module Fullness = Fullness.Make (A)
@@ -427,24 +352,24 @@ module Make (Theory : Theory.S) = struct
     let algebraic ps ty name =
       match Fullness.check ps ty with
       | Inv ->
-          Ctx.check_equal ps.ctx ty.c;
+          Ctx.check_equal (Ctx.of_ps ps) ty.c;
           Inv ({ ps; ty }, name)
       | NonInv (src, tgt) ->
-          Ctx.check_equal ps.ctx ty.c;
+          Ctx.check_equal (Ctx.of_ps ps) ty.c;
           NonInv ({ ps; src; tgt; total_ty = ty }, name)
       | No -> raise NotAlgebraic
 
     let register ps t ((name, _, _) as pp_data) =
       try
         let coh = algebraic ps t pp_data in
-        Hashtbl.add tbl (ps.tree, t.unchecked) coh;
+        Hashtbl.add tbl (ps, t.unchecked) coh;
         coh
       with
       | NotAlgebraic ->
           Error.not_valid_coherence name
             (Printf.sprintf "type %s not algebraic in pasting scheme %s"
                (Printing.ty_to_string t.unchecked)
-               (Printing.ctx_to_string (Unchecked.ps_to_ctx ps.tree)))
+               (Printing.ctx_to_string (Unchecked.ps_to_ctx ps)))
       | DoubledVar s ->
           Error.not_valid_coherence name
             (Printf.sprintf "variable %s appears twice in the context" s)
@@ -471,8 +396,8 @@ module Make (Theory : Theory.S) = struct
           let src_inclusion = PS.source ps in
           let tgt_inclusion = PS.target ps in
           let bdry = PS.bdry ps in
-          let src = Tm.check_in_ctx bdry.ctx src_unchkd in
-          let tgt = Tm.check_in_ctx bdry.ctx tgt_unchkd in
+          let src = Tm.check_in_ctx (Ctx.of_ps bdry) src_unchkd in
+          let tgt = Tm.check_in_ctx (Ctx.of_ps bdry) tgt_unchkd in
           let total_ty =
             Ty.morphism
               (Tm.apply_sub src src_inclusion)
@@ -518,7 +443,7 @@ module Make (Theory : Theory.S) = struct
 
     let forget c =
       let ps, ty, pp_data = data c in
-      (ps.tree, ty.unchecked, pp_data)
+      (ps, ty.unchecked, pp_data)
 
     let is_equal coh1 coh2 =
       coh1 == coh2
@@ -549,20 +474,160 @@ module Make (Theory : Theory.S) = struct
     let apply fun_ctx fun_ty fun_pp_data coh =
       let ps, ty, pp = forget coh in
       let ctx = fun_ctx (Unchecked.ps_to_ctx ps) in
-      let ps = (PS.mk (Ctx.check ctx)).tree in
+      let ps = PS.mk (Ctx.check ctx) in
       let db_sub = Unchecked.db_level_sub_inv ctx in
       let pp_data = Display_maps.pp_data_rename (fun_pp_data pp) db_sub in
       let ty = Unchecked.ty_apply_sub (fun_ty ty) db_sub in
       (check ps ty pp_data, db_sub)
   end
 
+  (** Operations on pasting schemes. *)
+  and PS : sig
+    exception Invalid
+
+    type t = ps
+
+    val to_string : t -> string
+    val mk : B.Ctx.t -> t
+    val bdry : t -> t
+    val source : t -> B.Sub.t
+    val target : t -> B.Sub.t
+    val is_equal : t -> t -> bool
+  end = struct
+    module Ctx = B.Ctx
+    module Sub = B.Sub
+
+    exception Invalid
+
+    open Syntax.Make (Core)
+
+    (** A pasting scheme. *)
+    type ps_derivation =
+      | PNil of (Var.t * Ty.t)
+      | PCons of ps_derivation * (Var.t * Ty.t) * (Var.t * Ty.t)
+      | PDrop of ps_derivation
+
+    type t = ps
+
+    let tbl : (Ctx.t, t) Hashtbl.t = Hashtbl.create 7829
+
+    (** Create a context from a pasting scheme. *)
+    let old_rep_to_ctx ps =
+      let rec list ps =
+        match ps with
+        | PDrop ps -> list ps
+        | PCons (ps, (x1, t1), (x2, t2)) ->
+            (x2, (t2.unchecked, true)) :: (x1, (t1.unchecked, true)) :: list ps
+        | PNil (x, t) -> [ (x, (t.unchecked, true)) ]
+      in
+      B.Ctx.check (list ps)
+
+    (** Dangling variable. *)
+    let rec marker (ps : ps_derivation) =
+      match ps with
+      | PNil (x, t) -> (x, t)
+      | PCons (_, _, f) -> f
+      | PDrop ps ->
+          let _, tf = marker ps in
+          let v = match tf.e with Obj -> raise Invalid | Arr (_, _, v) -> v in
+          let y = try Tm.to_var v with IsCoh -> raise Invalid in
+          let t =
+            let rec aux = function
+              | PNil (x, t) ->
+                  assert (x = y);
+                  t
+              | PCons (ps, (y', ty), (f, tf)) ->
+                  if y' = y then ty else if f = y then tf else aux ps
+              | PDrop ps -> aux ps
+            in
+            aux ps
+          in
+          (y, t)
+
+    (** Create a pasting scheme from a context. *)
+    let make_old (l : Ctx.t) =
+      let rec close ps (tx : Ty.t) =
+        match tx.e with Obj -> ps | Arr (tx, _, _) -> close (PDrop ps) tx
+      in
+      let build l =
+        let x0, ty, l =
+          match (l : (Var.t * Ty.t) list) with
+          | (x, ({ e = Obj; _ } as ty)) :: l -> (x, ty, l)
+          | _ -> raise Invalid
+        in
+        let rec aux ps (l : (Var.t * Ty.t) list) =
+          match l with
+          | (y, ty) :: (f, ({ e = Arr (_, u, v); _ } as tf)) :: l as l1 ->
+              let fx, fy =
+                try (Tm.to_var u, Tm.to_var v) with IsCoh -> raise Invalid
+              in
+              if y <> fy then raise Invalid;
+              let x, _ = marker ps in
+              if x = fx then (
+                let varps = Ctx.domain (old_rep_to_ctx ps) in
+                if List.mem f varps then raise (DoubledVar (Var.to_string f));
+                if List.mem y varps then raise (DoubledVar (Var.to_string y));
+                let ps = PCons (ps, (y, ty), (f, tf)) in
+                aux ps l)
+              else aux (PDrop ps) l1
+          | _ :: _ :: _ | [ (_, _) ] -> raise Invalid
+          | [] ->
+              let _, tx = marker ps in
+              close ps tx
+        in
+        aux (PNil (x0, ty)) l
+      in
+      build (List.rev l.c)
+
+    (* assumes that all ps are completed with enough PDrop in the end *)
+    let make_tree ps =
+      let rec find_previous ps list =
+        match ps with
+        | PNil x -> (Br list, PNil x)
+        | PCons (ps, _, _) -> (Br list, ps)
+        | PDrop _ as ps ->
+            let p, ps = build_till_previous ps in
+            (Br p, ps)
+      and build_till_previous ps =
+        match ps with
+        | PNil x -> ([], PNil x)
+        | PCons (ps, _, _) -> ([], ps)
+        | PDrop ps ->
+            let p, ps = find_previous ps [] in
+            let prev, ps = build_till_previous ps in
+            (p :: prev, ps)
+      in
+      Br (fst (build_till_previous ps))
+
+    let mk (l : Ctx.t) =
+      match Hashtbl.find_opt tbl l with
+      | Some ps -> ps
+      | None ->
+          let oldrep = make_old l in
+          let ps = make_tree oldrep in
+          Hashtbl.add tbl l ps;
+          ps
+
+    let to_string ps = Printing.ps_to_string ps
+    let bdry ps = mk (Ctx.check (Unchecked.ps_to_ctx (Unchecked.ps_bdry ps)))
+
+    let source ps =
+      Sub.check_to_ps (Ctx.of_ps ps) (Unchecked.ps_src ps) (bdry ps)
+
+    let target ps =
+      Sub.check_to_ps (Ctx.of_ps ps) (Unchecked.ps_tgt ps) (bdry ps)
+
+    let is_equal ps1 ps2 = ps1 == ps2 || Equality.is_equal_ps ps1 ps2
+  end
+
   and Core :
     (CoreSignature.S
-      with type PS.t = PS.t
+      with type Ty.t = Ty.t
       with type Coh.t = Coh.t
       with type Coh.innertm = Tm.t
       with type Tm.t = Tm.t) = struct
     module PS = PS
+    module Ty = Ty
     module Tm = Tm
     module Coh = Coh
   end
@@ -582,6 +647,7 @@ module Make (Theory : Theory.S) = struct
       }
 
       val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
+      val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> Sub.t
     end
 
     and Ctx : sig
@@ -597,25 +663,13 @@ module Make (Theory : Theory.S) = struct
       val check : (Coh.t, Tm.t) ctx -> t
       val is_equal : t -> t -> bool
       val check_equal : t -> t -> unit
-    end
-
-    and Ty : sig
-      type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
-      and expr = Obj | Arr of t * Tm.t * Tm.t
-
-      val to_string : t -> string
-      val is_equal : t -> t -> bool
-      val check_equal : t -> t -> unit
-      val morphism : Tm.t -> Tm.t -> Ty.t
-      val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
-      val apply_sub : t -> Sub.t -> t
-      val dim : t -> int
+      val of_ps : PS.t -> t
     end
   end =
     Builder.Make (Core)
 
-  module Ty = B.Ty
   module Ctx = B.Ctx
+  module Sub = B.Sub
   include Syntax.Make (Core)
 
   let check check_fn name =
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index 01417636..07f3d66b 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -5,6 +5,7 @@ module Make (_ : Theory.S) : sig
     type t
     type innertm = Tm.t
 
+    val ps : t -> PS.t
     val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
     val suspend : t -> t
     val is_equal : t -> t -> bool
@@ -15,6 +16,7 @@ module Make (_ : Theory.S) : sig
     val src : t -> (Coh.t, Tm.t) tm
     val tgt : t -> (Coh.t, Tm.t) tm
     val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
+    val ty : t -> Ty.t
 
     val check_noninv :
       ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
@@ -91,17 +93,15 @@ module Make (_ : Theory.S) : sig
     val check : (Coh.t, Tm.t) ctx -> t
   end
 
-  module PS : sig
+  and PS : sig
     exception Invalid
 
-    type t = private { tree : ps; ctx : Ctx.t }
+    type t = ps
 
     val mk : Ctx.t -> t
   end
 
-  module Core :
-    Core.S with type PS.t = PS.t with type Coh.t = Coh.t with type Tm.t = Tm.t
-
+  module Core : Core.S with type Coh.t = Coh.t with type Tm.t = Tm.t
   include module type of Syntax.Make (Core)
 
   val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
diff --git a/lib/meta_operations/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
index 56141964..70b4ca9b 100644
--- a/lib/meta_operations/cubical_composite.ml
+++ b/lib/meta_operations/cubical_composite.ml
@@ -384,7 +384,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     else
       let ps_f_c = F.ctx (Unchecked.ps_to_ctx ps) l_d0 in
       let _, names, _ = Unchecked.db_levels ps_f_c in
-      let ps_f = PS.((mk (Ctx.check ps_f_c)).tree) in
+      let ps_f = PS.(mk (Ctx.check ps_f_c)) in
       let l_psf = List.map (fun x -> Var.Db (fst (List.assoc x names))) l_d1 in
       let names = List.map (fun (x, (n, e)) -> (Var.Db n, (Var x, e))) names in
       (ps_f, l_psf, names)
diff --git a/lib/meta_operations/functorialisation.ml b/lib/meta_operations/functorialisation.ml
index 03f3670f..32df22a3 100644
--- a/lib/meta_operations/functorialisation.ml
+++ b/lib/meta_operations/functorialisation.ml
@@ -354,7 +354,7 @@ module Make (Theory : Theory.S) = struct
   let ps p l =
     let c = ctx (Unchecked.ps_to_ctx p) l in
     let _, names, _ = Unchecked.db_levels c in
-    ((PS.mk (Ctx.check c)).tree, names)
+    (PS.mk (Ctx.check c), names)
 
   let sub_w_tgt p s l =
     let s_f = sub_ps s l in

From 5f3bd03631164f8b58effed15ea8e926940a8a54 Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Fri, 28 Nov 2025 15:53:43 +0100
Subject: [PATCH 28/30] complete restructuration of the kernel

---
 lib/elaboration/elaborate.ml             |  26 +-
 lib/elaboration/translate_raw.ml         |   8 +-
 lib/internals/builder.ml                 |  74 ++---
 lib/internals/builder.mli                |  23 ++
 lib/internals/core.mli                   |  76 ++---
 lib/internals/display_maps.ml            |   4 +-
 lib/internals/display_maps.mli           |  27 +-
 lib/internals/equality.ml                |  13 +-
 lib/internals/equality.mli               |  21 +-
 lib/internals/fullness.ml                |  80 +----
 lib/internals/fullness.mli               |  57 +---
 lib/internals/kernel.ml                  | 394 ++++++++++-------------
 lib/internals/kernel.mli                 | 103 +-----
 lib/internals/kernelSignature.mli        | 314 +++++++++++++-----
 lib/internals/printing.ml                |  27 +-
 lib/internals/printing.mli               |  29 +-
 lib/internals/syntax.ml                  |  20 +-
 lib/internals/syntax.mli                 |  20 +-
 lib/internals/unchecked.ml               |  15 +-
 lib/internals/unchecked.mli              | 169 ++++------
 lib/lib/common.ml                        | 261 ++++++++++++++-
 lib/lib/common.mli                       | 261 ++++++++++++++-
 lib/meta_operations/builtin.ml           |  10 +-
 lib/meta_operations/comp.ml              |   4 +-
 lib/meta_operations/cones.ml             |   6 +-
 lib/meta_operations/construct.ml         |  27 +-
 lib/meta_operations/cubical_composite.ml |  51 +--
 lib/meta_operations/cylinders.ml         |   7 +-
 lib/meta_operations/eh.ml                |   4 +-
 lib/meta_operations/functorialisation.ml |  18 +-
 lib/meta_operations/inverse.ml           |  55 ++--
 lib/meta_operations/opposite.ml          | 155 +++++----
 lib/meta_operations/opposite.mli         |  14 +-
 lib/meta_operations/ps_reduction.ml      |   4 +-
 lib/meta_operations/telescope.ml         |  40 ++-
 rocq_plugin/src/export.ml                |   4 +-
 36 files changed, 1362 insertions(+), 1059 deletions(-)
 create mode 100644 lib/internals/builder.mli

diff --git a/lib/elaboration/elaborate.ml b/lib/elaboration/elaborate.ml
index de148e9c..4622bc81 100644
--- a/lib/elaboration/elaborate.ml
+++ b/lib/elaboration/elaborate.ml
@@ -47,15 +47,15 @@ module Make (Environment : Environments.S) = struct
       | Meta_tm _, Meta_tm _ when tm1 = tm2 -> ()
       | Meta_tm _, _ | _, Meta_tm _ -> Queue.enqueue cst.tm (tm1, tm2)
       | Var v1, Var v2 when v1 = v2 -> ()
-      | Coh (coh1, s1), Coh (coh2, s2) -> (
+      | Coh (_, coh1, s1), Coh (_, coh2, s2) -> (
           try
             Coh.check_equal coh1 coh2;
             unify_sub_ps cst s1 s2
           with Invalid_argument _ ->
             raise (NotUnifiable (Coh.to_string coh1, Coh.to_string coh2)))
-      | App (t1, s1), App (t2, s2) when t1 == t2 -> unify_sub cst s1 s2
-      | App (t, s), ((App _ | Coh _ | Var _) as tm2)
-      | ((Coh _ | Var _) as tm2), App (t, s) ->
+      | App (_, t1, s1), App (_, t2, s2) when t1 == t2 -> unify_sub cst s1 s2
+      | App (_, t, s), ((App _ | Coh _ | Var _) as tm2)
+      | ((Coh _ | Var _) as tm2), App (_, t, s) ->
           unify_tm cst (Unchecked.tm_apply_sub (Tm.develop t) s) tm2
       | Var _, Coh _ | Coh _, Var _ | Var _, Var _ ->
           raise
@@ -99,15 +99,17 @@ module Make (Environment : Environments.S) = struct
       | Meta_tm j when i = j -> tm'
       | Meta_tm _ -> tm
       | Var v -> Var v
-      | Coh (c, s) ->
+      | Coh (mod_coh, c, s) ->
           Coh
-            ( c,
+            ( mod_coh,
+              c,
               List.map
                 (fun (t, expl) -> (tm_replace_meta_tm (i, tm') t, expl))
                 s )
-      | App (t, s) ->
+      | App (mod_tm, t, s) ->
           App
-            ( t,
+            ( mod_tm,
+              t,
               List.map
                 (fun (x, (t, e)) -> (x, (tm_replace_meta_tm (i, tm') t, e)))
                 s )
@@ -214,18 +216,18 @@ module Make (Environment : Environments.S) = struct
               (Printf.sprintf "variable %s not found in context"
                  (Var.to_string v)))
       | Meta_tm i -> (t, List.assoc i meta_ctx)
-      | Coh (c, s) ->
+      | Coh (mod_coh, c, s) ->
           let ps, ty, _ = Coh.forget c in
           let tgt = Unchecked.ps_to_ctx ps in
           let s1 = Unchecked.sub_ps_to_sub s in
           let s1 = sub ctx meta_ctx s1 tgt cst in
-          ( Coh (c, List.map (fun (_, (t, expl)) -> (t, expl)) s1),
+          ( Coh (mod_coh, c, List.map (fun (_, (t, expl)) -> (t, expl)) s1),
             Unchecked.ty_apply_sub ty s1 )
-      | App (t, s) ->
+      | App (mod_tm, t, s) ->
           let tgt = Tm.ctx t in
           let ty = t.ty.unchecked in
           let s = sub ctx meta_ctx s tgt cst in
-          (App (t, s), Unchecked.ty_apply_sub ty s)
+          (App (mod_tm, t, s), Unchecked.ty_apply_sub ty s)
 
     and sub src meta_ctx s tgt cst =
       Io.info ~v:5
diff --git a/lib/elaboration/translate_raw.ml b/lib/elaboration/translate_raw.ml
index 3016ab53..17b229a0 100644
--- a/lib/elaboration/translate_raw.ml
+++ b/lib/elaboration/translate_raw.ml
@@ -7,6 +7,8 @@ module Make (Environment : Environments.S) = struct
   module RawElab = Raw.Make (Environment)
   open Environment
 
+  let mod_tm = assert false
+
   let rec head_susp = function
     | VarR _ -> 0
     | Sub (_, _, None, _) -> 0
@@ -23,7 +25,7 @@ module Make (Environment : Environments.S) = struct
       let t = Functorialisation.coh_successively coh func in
       let ctx = Tm.ctx t in
       let s, meta_types = sub s ctx expl in
-      (App (t, s), meta_types)
+      (App (mod_tm, t, s), meta_types)
     in
     let make_app tm s susp expl =
       let tm = Suspension.checked_tm susp tm in
@@ -32,7 +34,7 @@ module Make (Environment : Environments.S) = struct
       let t = Functorialisation.tm tm func in
       let ctx = Tm.ctx t in
       let s, meta_types = sub s ctx expl in
-      (App (t, s), meta_types)
+      (App (mod_tm, t, s), meta_types)
     in
     match t with
     | VarR v -> (Var v, [])
@@ -46,7 +48,7 @@ module Make (Environment : Environments.S) = struct
             let t = Functorialisation.tm t func in
             let c = Tm.ctx t in
             let s, meta_types = sub s c expl in
-            (App (t, s), meta_types))
+            (App (mod_tm, t, s), meta_types))
     | Sub (BuiltinR b, s, susp, expl) -> (
         match b with
         | Comp ->
diff --git a/lib/internals/builder.ml b/lib/internals/builder.ml
index c55dbbed..55e92506 100644
--- a/lib/internals/builder.ml
+++ b/lib/internals/builder.ml
@@ -1,38 +1,31 @@
 open Std
 open Common
+module CoreSignature = Core
 
-module Make (Core : Core.S) = struct
-  exception IsObj
-  exception IsCoh
-  exception InvalidSubTarget of string * string
-  exception MetaVariable
+exception IsObj
+exception IsCoh
+exception InvalidSubTarget of string * string
+exception MetaVariable
 
+module Make (Core : Core.S) = struct
+  open Syntax.Make (Core)
   open Core
 
   (** Operations on substitutions. *)
-  module rec Sub : sig
-    type expr = Tm.t list
-
-    type t = private {
-      list : expr;
-      src : Ctx.t;
-      tgt : Ctx.t;
-      unchecked : (Coh.t, Tm.t) sub;
-    }
-
-    val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
-    val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> Sub.t
-  end = struct
+  module rec Sub :
+    (KernelSignature.SubS
+      with type checked_tm = Tm.t
+       and type checked_coh = Coh.t
+       and type checked_ctx = Ctx.t) = struct
+    type checked_tm = Tm.t
+    type checked_coh = Coh.t
+    type checked_ctx = Ctx.t
     type expr = Tm.t list
+    type t = { list : expr; src : Ctx.t; tgt : Ctx.t; unchecked : sub }
 
-    type t = {
-      list : expr;
-      src : Ctx.t;
-      tgt : Ctx.t;
-      unchecked : (Coh.t, Tm.t) sub;
-    }
-
-    open Syntax.Make (Core)
+    let forget s = s.unchecked
+    let src s = s.src
+    let tgt s = s.tgt
 
     let check src s tgt =
       Io.info ~v:5
@@ -77,24 +70,17 @@ module Make (Core : Core.S) = struct
   end
 
   (** A context, associating a type to each context variable. *)
-  and Ctx : sig
-    type t = private { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
-
-    val empty : unit -> t
-    val to_string : t -> string
-    val ty_var : t -> Var.t -> Ty.t
-    val domain : t -> Var.t list
-    val extend : t -> expl:bool -> Var.t -> (Coh.t, Tm.t) ty -> t
-    val forget : t -> (Coh.t, Tm.t) ctx
-    val check : (Coh.t, Tm.t) ctx -> t
-    val check_notin : t -> Var.t -> unit
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val of_ps : PS.t -> t
-  end = struct
-    type t = { c : (Var.t * Ty.t) list; unchecked : (Coh.t, Tm.t) ctx }
-
-    open Syntax.Make (Core)
+  and Ctx :
+    (KernelSignature.CtxS
+      with type checked_ty = Ty.t
+       and type checked_tm = Tm.t
+       and type checked_coh = Coh.t
+       and type checked_ps = PS.t) = struct
+    type checked_ty = Ty.t
+    type checked_tm = Tm.t
+    type checked_coh = Coh.t
+    type checked_ps = PS.t
+    type t = { c : (Var.t * Ty.t) list; unchecked : ctx }
 
     let tbl : (ctx, Ctx.t) Hashtbl.t = Hashtbl.create 7829
 
diff --git a/lib/internals/builder.mli b/lib/internals/builder.mli
new file mode 100644
index 00000000..49aaacb2
--- /dev/null
+++ b/lib/internals/builder.mli
@@ -0,0 +1,23 @@
+module CoreSignature = Core
+
+exception IsObj
+exception IsCoh
+exception InvalidSubTarget of string * string
+exception MetaVariable
+
+module Make : functor (Core : Core.S) -> sig
+  open Core
+
+  module Ctx :
+    KernelSignature.CtxS
+      with type checked_ty = Ty.t
+       and type checked_tm = Tm.t
+       and type checked_coh = Coh.t
+       and type checked_ps = PS.t
+
+  module Sub :
+    KernelSignature.SubS
+      with type checked_tm = Tm.t
+       and type checked_coh = Coh.t
+       and type checked_ctx = Ctx.t
+end
diff --git a/lib/internals/core.mli b/lib/internals/core.mli
index bc850ee6..76fb9493 100644
--- a/lib/internals/core.mli
+++ b/lib/internals/core.mli
@@ -1,53 +1,31 @@
 open Common
 
 module type S = sig
-  module PS : sig
-    type t = ps
-  end
-
-  module Coh : sig
-    type t
-    type innertm
-
-    val suspend : t -> t
-    val forget : t -> ps * (t, innertm) ty * pp_data
-    val to_string : ?unroll:bool -> t -> string
-    val func_data : t -> (Var.t * int) list list
-    val is_equal : t -> t -> bool
-  end
-
-  module Tm : sig
-    type t
-
-    val develop : t -> (Coh.t, t) tm
-    val func_data : t -> (Var.t * int) list list option
-    val name : t -> string option
-    val full_name : t -> string option
-    val ctx : t -> (Coh.t, t) ctx
-    val is_equal : t -> t -> bool
-    val to_var : t -> Var.t
-
-    val check :
-      (Coh.t, t) ctx -> ?ty:(Coh.t, t) ty -> ?name:pp_data -> (Coh.t, t) tm -> t
-
-    val ty : t -> (Coh.t, t) ty
-    val forget : t -> (Coh.t, t) tm
-
-    val apply :
-      ((Coh.t, t) ctx -> (Coh.t, t) ctx) ->
-      ((Coh.t, t) tm -> (Coh.t, t) tm) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, t) sub
-  end
-
-  module Ty : sig
-    type t
-
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val forget : t -> (Coh.t, Tm.t) ty
-    val check_with_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ty -> t
-  end
+  module PS : KernelSignature.PSS
+
+  module rec Coh :
+    (KernelSignature.CohS
+      with type innertm = Tm.t
+       and type checked_tm = Tm.t
+       and type checked_ty = Ty.t)
+
+  and Tm :
+    (KernelSignature.TmS
+      with type checked_coh = Coh.t
+       and type checked_ty = Ty.t)
+
+  and Ty :
+    (KernelSignature.TyS
+      with type checked_tm = Tm.t
+       and type checked_coh = Coh.t)
+
+  type ty = (Coh.t, Tm.t) pty
+  type tm = (Coh.t, Tm.t) ptm
+  type sub = (Coh.t, Tm.t) psub
+  type sub_ps = (Coh.t, Tm.t) psub_ps
+  type ctx = (Coh.t, Tm.t) pctx
+  type constr = (Coh.t, Tm.t) pconstr
+  type meta_ctx = (int * ty) list
+  type value = VCoh of Coh.t | VTm of Tm.t
+  type decls = (value * string) list
 end
diff --git a/lib/internals/display_maps.ml b/lib/internals/display_maps.ml
index f2eb7fcb..1708aabe 100644
--- a/lib/internals/display_maps.ml
+++ b/lib/internals/display_maps.ml
@@ -1,8 +1,8 @@
 open Std
 open Common
 
-module Make (Core : Core.S) = struct
-  module Unchecked = Unchecked.Make (Core)
+module Make (C : Core.S) = struct
+  module Unchecked = Unchecked.Make (C)
 
   let var_apply_sub v s =
     match Unchecked.tm_apply_sub (Var v) s with
diff --git a/lib/internals/display_maps.mli b/lib/internals/display_maps.mli
index bb5a801c..6b98fc07 100644
--- a/lib/internals/display_maps.mli
+++ b/lib/internals/display_maps.mli
@@ -1,23 +1,10 @@
-module Make (Core : Core.S) : sig
-  open Core
-  open Common
+open Common
 
-  val var_apply_sub : Var.t -> (Coh.t, Tm.t) sub -> Var.t
+module Make (C : Core.S) : sig
+  open C
 
-  val pullback :
-    (Coh.t, Tm.t) ctx ->
-    (Coh.t, Tm.t) sub ->
-    (Coh.t, Tm.t) ctx ->
-    (Coh.t, Tm.t) sub ->
-    (Coh.t, Tm.t) ctx * (Coh.t, Tm.t) sub
-
-  val glue :
-    (Coh.t, Tm.t) sub ->
-    (Coh.t, Tm.t) sub ->
-    (Coh.t, Tm.t) sub ->
-    (Coh.t, Tm.t) ctx ->
-    (Coh.t, Tm.t) sub ->
-    (Coh.t, Tm.t) sub
-
-  val pp_data_rename : pp_data -> (Coh.t, Tm.t) sub -> pp_data
+  val var_apply_sub : Var.t -> sub -> Var.t
+  val pullback : ctx -> sub -> ctx -> sub -> ctx * sub
+  val glue : sub -> sub -> sub -> ctx -> sub -> sub
+  val pp_data_rename : pp_data -> sub -> pp_data
 end
diff --git a/lib/internals/equality.ml b/lib/internals/equality.ml
index fdb12d53..bb0ebe88 100644
--- a/lib/internals/equality.ml
+++ b/lib/internals/equality.ml
@@ -1,10 +1,10 @@
 open Std
 open Common
 
-module Make (Core : Core.S) = struct
-  open Core
-  module Unchecked = Unchecked.Make (Core)
-  module Printing = Printing.Make (Core)
+module Make (C : Core.S) = struct
+  module Unchecked = Unchecked.Make (C)
+  module Printing = Printing.Make (C)
+  open C
 
   let rec is_equal_ps ps1 ps2 =
     match (ps1, ps2) with
@@ -35,7 +35,7 @@ module Make (Core : Core.S) = struct
     | Coh (coh1, s1), Coh (coh2, s2) ->
         Coh.is_equal coh1 coh2 && is_equal_sub_ps s1 s2
     | App (t1, s1), App (t2, s2) when t1 == t2 ->
-        is_equal_sub_on_support t1 s1 s2
+        is_equal_sub_on_support (Tm.develop t1) s1 s2
     | App (t, s), ((Coh _ | App _ | Var _) as tm2)
     | ((Coh _ | Var _) as tm2), App (t, s) ->
         let c = Tm.develop t in
@@ -57,8 +57,7 @@ module Make (Core : Core.S) = struct
     List.for_all2
       (fun (x, (t1, _)) (y, (t2, _)) ->
         Var.is_equal x y
-        && ((not (Unchecked.tm_contains_var (Tm.develop t) x))
-           || is_equal_tm t1 t2))
+        && ((not (Unchecked.tm_contains_var t x)) || is_equal_tm t1 t2))
       s1 s2
 
   let rec is_equal_ctx ctx1 ctx2 =
diff --git a/lib/internals/equality.mli b/lib/internals/equality.mli
index 501bdab7..28eb3f2f 100644
--- a/lib/internals/equality.mli
+++ b/lib/internals/equality.mli
@@ -1,14 +1,15 @@
-module Make (Core : Core.S) : sig
-  open Core
-  open Common
+open Common
 
-  val check_equal_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx -> unit
+module Make (C : Core.S) : sig
+  open C
+
+  val check_equal_ctx : ctx -> ctx -> unit
   val check_equal_ps : ps -> ps -> unit
-  val check_equal_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty -> unit
-  val check_equal_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> unit
-  val check_equal_sub_ps : (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps -> unit
-  val is_equal_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx -> bool
+  val check_equal_ty : ty -> ty -> unit
+  val check_equal_tm : tm -> tm -> unit
+  val check_equal_sub_ps : sub_ps -> sub_ps -> unit
+  val is_equal_ctx : ctx -> ctx -> bool
   val is_equal_ps : ps -> ps -> bool
-  val is_equal_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty -> bool
-  val is_equal_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> bool
+  val is_equal_ty : ty -> ty -> bool
+  val is_equal_tm : tm -> tm -> bool
 end
diff --git a/lib/internals/fullness.ml b/lib/internals/fullness.ml
index d6b9396a..9be75995 100644
--- a/lib/internals/fullness.ml
+++ b/lib/internals/fullness.ml
@@ -1,81 +1,29 @@
 open Std
-open Common
 
-module type FArgs = sig
-  module Theory : Theory.S
-
-  module Coh : sig
-    type t
-  end
-
-  module Ctx : sig
-    type t
-
-    val domain : t -> Var.t list
-  end
-
-  module rec Sub : sig
-    type t = private {
-      list : Tm.t list;
-      src : Ctx.t;
-      tgt : Ctx.t;
-      unchecked : (Coh.t, Tm.t) sub;
-    }
-  end
-
-  and Ty : sig
-    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-
-    val dim : t -> int
-  end
-
-  and Tm : sig
-    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
-
-    and t = private {
-      ty : Ty.t;
-      e : expr;
-      unchecked : (Coh.t, t) tm;
-      mutable developped : (Coh.t, t) tm option;
-      name : pp_data option;
-    }
-
-    val preimage : t -> Sub.t -> t
-  end
-
-  module PS : sig
-    type t
-
-    val source : t -> Sub.t
-    val target : t -> Sub.t
-  end
-end
-
-module Make (A : FArgs) = struct
-  open A
+module Make (K : KernelSignature.S) = struct
+  open K
 
   type res = Inv | NonInv of Tm.t * Tm.t | No
 
-  let rec tm_free_vars (tm : Tm.t) =
-    let fvty = ty_free_vars tm.ty in
-    match tm.e with
+  let rec tm_free_vars tm =
+    let fvty = ty_free_vars (Tm.checked_ty tm) in
+    match Tm.expr tm with
     | Var x -> x :: fvty
     | Coh (_, sub) | App (_, sub) -> sub_free_vars sub
 
-  and ty_free_vars (ty : Ty.t) =
-    match ty.e with
+  and ty_free_vars ty =
+    match Ty.expr ty with
     | Obj -> []
     | Arr (t, u, v) ->
         List.unions [ ty_free_vars t; tm_free_vars u; tm_free_vars v ]
 
-  and sub_free_vars (s : Sub.t) = List.concat (List.map tm_free_vars s.list)
+  and sub_free_vars s = List.concat (List.map tm_free_vars s.list)
 
-  let ty_contains_all_vars (t : Ty.t) =
-    List.included (Ctx.domain t.c) (ty_free_vars t)
+  let ty_contains_all_vars t =
+    List.included (Ctx.domain (Ty.ctx t)) (ty_free_vars t)
 
-  let tm_contains_all_vars (t : Tm.t) =
-    List.included (Ctx.domain t.ty.c) (tm_free_vars t)
+  let tm_contains_all_vars t =
+    List.included (Ctx.domain (Ty.ctx (Tm.checked_ty t))) (tm_free_vars t)
 
   let is_inv_dim t =
     match Theory.theory.invertibility with
@@ -86,8 +34,8 @@ module Make (A : FArgs) = struct
   let check_full_inv t =
     if is_inv_dim t || ty_contains_all_vars t then Inv else No
 
-  let check_full_noninv ps (t : Ty.t) =
-    match t.e with
+  let check_full_noninv ps t =
+    match Ty.expr t with
     | Obj -> No
     | Arr (_, src, tgt) -> (
         try
diff --git a/lib/internals/fullness.mli b/lib/internals/fullness.mli
index d42cba4f..3a13b815 100644
--- a/lib/internals/fullness.mli
+++ b/lib/internals/fullness.mli
@@ -1,58 +1,5 @@
-open Common
-
-module type FArgs = sig
-  module Theory : Theory.S
-
-  module Coh : sig
-    type t
-  end
-
-  module Ctx : sig
-    type t
-
-    val domain : t -> Var.t list
-  end
-
-  module rec Sub : sig
-    type t = private {
-      list : Tm.t list;
-      src : Ctx.t;
-      tgt : Ctx.t;
-      unchecked : (Coh.t, Tm.t) sub;
-    }
-  end
-
-  and Ty : sig
-    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-
-    val dim : t -> int
-  end
-
-  and Tm : sig
-    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
-
-    and t = private {
-      ty : Ty.t;
-      e : expr;
-      unchecked : (Coh.t, t) tm;
-      mutable developped : (Coh.t, t) tm option;
-      name : pp_data option;
-    }
-
-    val preimage : t -> Sub.t -> t
-  end
-
-  module PS : sig
-    type t
-
-    val source : t -> Sub.t
-    val target : t -> Sub.t
-  end
-end
-
-module Make : functor (A : FArgs) -> sig
-  open A
+module Make : functor (K : KernelSignature.S) -> sig
+  open K
 
   type res = Inv | NonInv of Tm.t * Tm.t | No
 
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index 199df118..da06df33 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -6,28 +6,26 @@ exception IsObj
 exception MetaVariable
 
 module Make (Theory : Theory.S) = struct
-  module rec Ty : sig
-    type t = private { c : B.Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val morphism : Tm.t -> Tm.t -> Ty.t
-    val check : B.Ctx.t -> (Coh.t, Tm.t) ty -> t
-    val apply_sub : t -> B.Sub.t -> t
-    val dim : t -> int
-    val forget : t -> (Coh.t, Tm.t) ty
-    val check_with_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ty -> t
-  end = struct
-    module Ctx = B.Ctx
-    module Sub = B.Sub
+  module rec RTy :
+    (KernelSignature.TyS
+      with type checked_tm = K.Tm.t
+       and type checked_coh = K.Coh.t
+       and type checked_sub = K.Sub.t
+       and type checked_ctx = K.Ctx.t) = struct
+    open K
     open Syntax.Make (Core)
 
+    type checked_ctx = Ctx.t
+    type checked_coh = Coh.t
+    type checked_tm = Tm.t
+    type checked_sub = Sub.t
+
     type expr = Obj | Arr of t * Tm.t * Tm.t  (** A type exepression. *)
-    and t = { c : B.Ctx.t; e : expr; unchecked : ty }
+    and t = { c : Ctx.t; e : expr; unchecked : ty }
 
-    let tbl : (B.Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
+    let tbl : (Ctx.t * ty, Ty.t) Hashtbl.t = Hashtbl.create 7829
+    let ctx t = t.c
+    let expr t = t.e
 
     let rec check c t =
       Io.info ~v:5
@@ -92,60 +90,20 @@ module Make (Theory : Theory.S) = struct
   end
 
   (** Operations on terms. *)
-  and Tm : sig
-    type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
-
-    and t = private {
-      ty : Ty.t;
-      e : expr;
-      unchecked : (Coh.t, t) tm;
-      mutable developped : (Coh.t, t) tm option;
-      name : pp_data option;
-    }
-
-    (* Data extraction *)
-    val to_var : t -> Var.t
-    val ty : t -> (Coh.t, Tm.t) ty
-    val ctx : t -> (Coh.t, Tm.t) ctx
-    val forget : t -> (Coh.t, Tm.t) tm
-    val constr : t -> (Coh.t, Tm.t) constr
-    val name : t -> string option
-    val full_name : t -> string option
-    val func_data : t -> (Var.t * int) list list option
-    val pp_data : t -> pp_data option
-    val to_string : t -> string
-
-    (* Production of terms *)
-    val of_coh : Coh.t -> t
-
-    val check_in_ctx :
-      B.Ctx.t -> ?ty:Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t
-
-    val check :
-      (Coh.t, Tm.t) ctx ->
-      ?ty:(Coh.t, Tm.t) ty ->
-      ?name:pp_data ->
-      (Coh.t, Tm.t) tm ->
-      t
-
-    val apply_sub : t -> B.Sub.t -> t
-    val preimage : t -> B.Sub.t -> t
-    val develop : t -> (Coh.t, Tm.t) tm
-
-    val apply :
-      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-      ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) sub
-
-    val is_equal : t -> t -> bool
-  end = struct
+  and RTm :
+    (KernelSignature.TmS
+      with type checked_coh = K.Coh.t
+       and type checked_sub = K.Sub.t
+       and type checked_ty = K.Ty.t
+       and type checked_ctx = K.Ctx.t) = struct
+    open K
     open Syntax.Make (Core)
-    module Ctx = B.Ctx
-    module Sub = B.Sub
 
-    type expr = Var of Var.t | Coh of Coh.t * B.Sub.t | App of Tm.t * B.Sub.t
+    type checked_coh = Coh.t
+    type checked_sub = Sub.t
+    type checked_ty = Ty.t
+    type checked_ctx = Ctx.t
+    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
 
     type t = {
       ty : Ty.t;
@@ -155,8 +113,10 @@ module Make (Theory : Theory.S) = struct
       name : pp_data option;
     }
 
-    let ty t = t.ty.unchecked
-    let tbl : (B.Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
+    let ty t = Ty.forget t.ty
+    let checked_ty t = t.ty
+    let expr t = t.e
+    let tbl : (Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829
     let forget tm = tm.unchecked
     let constr tm = (forget tm, ty tm)
 
@@ -171,7 +131,7 @@ module Make (Theory : Theory.S) = struct
         | None -> (
             match t with
             | Var x ->
-                let e, ty = (Var x, Ty.check c (Ctx.ty_var c x).unchecked) in
+                let e, ty = (Var x, Ty.(check c (forget (Ctx.ty_var c x)))) in
                 { ty; e; unchecked = t; developped = Some t; name }
             | Meta_tm _ -> raise MetaVariable
             | Coh (coh, s) ->
@@ -182,7 +142,7 @@ module Make (Theory : Theory.S) = struct
                 tm
             | App (u, s) ->
                 let ty = u.ty in
-                let sub = Sub.check c s ty.c in
+                let sub = Sub.check c s (Ty.ctx ty) in
                 let e, ty = (App (u, sub), Ty.apply_sub ty sub) in
                 let tm = { ty; e; unchecked = t; developped = None; name } in
                 Hashtbl.add tbl (c, t) tm;
@@ -224,25 +184,25 @@ module Make (Theory : Theory.S) = struct
           | Coh _ -> raise IsCoh
           | App _ | Meta_tm _ -> assert false)
 
-    let apply_sub t (sub : B.Sub.t) =
-      Ctx.check_equal sub.tgt t.ty.c;
+    let preimage t sub =
+      Ctx.check_equal (Sub.src sub) (Ty.ctx t.ty);
+      let c = Sub.tgt sub in
+      let t = Unchecked.tm_sub_preimage (forget t) (Sub.forget sub) in
+      check_in_ctx c t
+
+    let apply_sub t (sub : Sub.t) =
+      Ctx.check_equal sub.tgt (Ty.ctx t.ty);
       let c = sub.src in
       let ty = Ty.apply_sub t.ty sub in
       let t = Unchecked.tm_apply_sub (forget t) sub.unchecked in
       check_in_ctx c ~ty t
 
-    let preimage t (sub : B.Sub.t) =
-      Ctx.check_equal sub.src t.ty.c;
-      let c = sub.tgt in
-      let t = Unchecked.tm_sub_preimage (forget t) sub.unchecked in
-      check_in_ctx c t
-
     let is_equal t1 t2 =
-      Ctx.is_equal t1.ty.c t2.ty.c
+      Ctx.is_equal (Ty.ctx t1.ty) (Ty.ctx t2.ty)
       && Equality.is_equal_tm t1.unchecked t2.unchecked
 
     let apply fun_ctx fun_tm fun_pp_data tm =
-      let c = fun_ctx (Ctx.forget tm.ty.c) in
+      let c = fun_ctx (Ctx.forget (Ty.ctx tm.ty)) in
       let db_sub = Unchecked.db_level_sub_inv c in
       let c, _, _ = Unchecked.db_levels c in
       let c = Ctx.check c in
@@ -255,7 +215,7 @@ module Make (Theory : Theory.S) = struct
       in
       (check_in_ctx c ?name newexp, db_sub)
 
-    let ctx t = Ctx.forget t.ty.c
+    let ctx t = Ctx.forget (Ty.ctx t.ty)
     let name t = Option.map Printing.pp_data_to_string t.name
     let full_name t = Option.map Printing.full_name t.name
     let func_data t = Option.map (fun (_, _, f) -> f) t.name
@@ -274,42 +234,18 @@ module Make (Theory : Theory.S) = struct
   end
 
   (** A coherence. *)
-  and Coh : sig
-    type t
-    type innertm = Tm.t
+  and RCoh :
+    (KernelSignature.CohS
+      with type innertm = K.Tm.t
+       and type checked_ps = K.PS.t
+       and type checked_tm = K.Tm.t
+       and type checked_ty = K.Ty.t) = struct
+    open K
 
-    val ps : t -> PS.t
-    val ty : t -> Ty.t
-    val src : t -> (t, Tm.t) tm
-    val tgt : t -> (t, Tm.t) tm
-    val suspend : t -> t
-    val check : ps -> (t, Tm.t) ty -> pp_data -> t
-    val check_noninv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
-    val check_inv : ps -> (t, Tm.t) tm -> (t, Tm.t) tm -> pp_data -> t
-    val to_string : ?unroll:bool -> t -> string
-    val is_inv : t -> bool
-    val noninv_srctgt : t -> (t, Tm.t) tm * (t, Tm.t) tm * (t, Tm.t) ty
-    val forget : t -> ps * (t, Tm.t) ty * pp_data
-    val func_data : t -> (Var.t * int) list list
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val dim : t -> int
-
-    val apply_ps :
-      (ps -> ps) ->
-      ((t, Tm.t) ty -> (t, Tm.t) ty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t
-
-    val apply :
-      ((t, Tm.t) ctx -> (t, Tm.t) ctx) ->
-      ((t, Tm.t) ty -> (t, Tm.t) ty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (t, Tm.t) sub
-  end = struct
     type innertm = Tm.t
+    type checked_ps = PS.t
+    type checked_tm = Tm.t
+    type checked_ty = Ty.t
     type cohInv = { ps : PS.t; ty : Ty.t }
     type cohNonInv = { ps : PS.t; src : Tm.t; tgt : Tm.t; total_ty : Ty.t }
     type t = Inv of cohInv * pp_data | NonInv of cohNonInv * pp_data
@@ -320,18 +256,7 @@ module Make (Theory : Theory.S) = struct
     let tbl_inv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
     let tbl_noninv : (ps * tm * tm, Coh.t) Hashtbl.t = Hashtbl.create 7829
 
-    module A = struct
-      module Theory = Theory
-      module PS = PS
-      module Sub = B.Sub
-      module Coh = Coh
-      module Tm = Tm
-      module Ctx = B.Ctx
-      module Ty = Ty
-    end
-
-    module Fullness = Fullness.Make (A)
-    module Ctx = B.Ctx
+    module Fullness = Fullness.Make (K)
 
     exception NotAlgebraic
 
@@ -342,33 +267,37 @@ module Make (Theory : Theory.S) = struct
       | NonInv (data, _) -> data.total_ty
 
     let src c =
-      match (ty c).e with Obj -> raise IsObj | Arr (_, s, _) -> Tm.forget s
+      match Ty.expr (ty c) with
+      | Obj -> raise IsObj
+      | Arr (_, s, _) -> Tm.forget s
 
     let tgt c =
-      match (ty c).e with Obj -> raise IsObj | Arr (_, _, t) -> Tm.forget t
+      match Ty.expr (ty c) with
+      | Obj -> raise IsObj
+      | Arr (_, _, t) -> Tm.forget t
 
     let is_inv = function Inv (_, _) -> true | NonInv (_, _) -> false
 
     let algebraic ps ty name =
       match Fullness.check ps ty with
       | Inv ->
-          Ctx.check_equal (Ctx.of_ps ps) ty.c;
+          Ctx.check_equal (Ctx.of_ps ps) (Ty.ctx ty);
           Inv ({ ps; ty }, name)
       | NonInv (src, tgt) ->
-          Ctx.check_equal (Ctx.of_ps ps) ty.c;
+          Ctx.check_equal (Ctx.of_ps ps) (Ty.ctx ty);
           NonInv ({ ps; src; tgt; total_ty = ty }, name)
       | No -> raise NotAlgebraic
 
     let register ps t ((name, _, _) as pp_data) =
       try
         let coh = algebraic ps t pp_data in
-        Hashtbl.add tbl (ps, t.unchecked) coh;
+        Hashtbl.add tbl (ps, Ty.forget t) coh;
         coh
       with
       | NotAlgebraic ->
           Error.not_valid_coherence name
             (Printf.sprintf "type %s not algebraic in pasting scheme %s"
-               (Printing.ty_to_string t.unchecked)
+               (Printing.ty_to_string (Ty.forget t))
                (Printing.ctx_to_string (Unchecked.ps_to_ctx ps)))
       | DoubledVar s ->
           Error.not_valid_coherence name
@@ -430,7 +359,7 @@ module Make (Theory : Theory.S) = struct
     let noninv_srctgt c =
       match c with
       | Inv (_, _) -> Error.fatal "non-invertible data of an invertible coh"
-      | NonInv (d, _) -> (Tm.forget d.src, Tm.forget d.tgt, d.src.ty.unchecked)
+      | NonInv (d, _) -> (Tm.forget d.src, Tm.forget d.tgt, Tm.ty d.src)
 
     let dim c =
       let ty =
@@ -443,7 +372,7 @@ module Make (Theory : Theory.S) = struct
 
     let forget c =
       let ps, ty, pp_data = data c in
-      (ps, ty.unchecked, pp_data)
+      (ps, Ty.forget ty, pp_data)
 
     let is_equal coh1 coh2 =
       coh1 == coh2
@@ -482,25 +411,16 @@ module Make (Theory : Theory.S) = struct
   end
 
   (** Operations on pasting schemes. *)
-  and PS : sig
-    exception Invalid
-
-    type t = ps
-
-    val to_string : t -> string
-    val mk : B.Ctx.t -> t
-    val bdry : t -> t
-    val source : t -> B.Sub.t
-    val target : t -> B.Sub.t
-    val is_equal : t -> t -> bool
-  end = struct
-    module Ctx = B.Ctx
-    module Sub = B.Sub
-
-    exception Invalid
-
+  and RPS :
+    (KernelSignature.PSS
+      with type inner_ctx = K.Ctx.t
+       and type checked_sub = K.Sub.t) = struct
+    open K
     open Syntax.Make (Core)
 
+    type checked_sub = Sub.t
+    type inner_ctx = Ctx.t
+
     (** A pasting scheme. *)
     type ps_derivation =
       | PNil of (Var.t * Ty.t)
@@ -517,10 +437,10 @@ module Make (Theory : Theory.S) = struct
         match ps with
         | PDrop ps -> list ps
         | PCons (ps, (x1, t1), (x2, t2)) ->
-            (x2, (t2.unchecked, true)) :: (x1, (t1.unchecked, true)) :: list ps
-        | PNil (x, t) -> [ (x, (t.unchecked, true)) ]
+            (x2, (Ty.forget t2, true)) :: (x1, (Ty.forget t1, true)) :: list ps
+        | PNil (x, t) -> [ (x, (Ty.forget t, true)) ]
       in
-      B.Ctx.check (list ps)
+      Ctx.check (list ps)
 
     (** Dangling variable. *)
     let rec marker (ps : ps_derivation) =
@@ -529,8 +449,10 @@ module Make (Theory : Theory.S) = struct
       | PCons (_, _, f) -> f
       | PDrop ps ->
           let _, tf = marker ps in
-          let v = match tf.e with Obj -> raise Invalid | Arr (_, _, v) -> v in
-          let y = try Tm.to_var v with IsCoh -> raise Invalid in
+          let v =
+            match Ty.expr tf with Obj -> raise InvalidPS | Arr (_, _, v) -> v
+          in
+          let y = try Tm.to_var v with IsCoh -> raise InvalidPS in
           let t =
             let rec aux = function
               | PNil (x, t) ->
@@ -547,30 +469,39 @@ module Make (Theory : Theory.S) = struct
     (** Create a pasting scheme from a context. *)
     let make_old (l : Ctx.t) =
       let rec close ps (tx : Ty.t) =
-        match tx.e with Obj -> ps | Arr (tx, _, _) -> close (PDrop ps) tx
+        match Ty.expr tx with
+        | Obj -> ps
+        | Arr (tx, _, _) -> close (PDrop ps) tx
       in
       let build l =
         let x0, ty, l =
           match (l : (Var.t * Ty.t) list) with
-          | (x, ({ e = Obj; _ } as ty)) :: l -> (x, ty, l)
-          | _ -> raise Invalid
+          | (x, ty) :: l -> (
+              match Ty.expr ty with Obj -> (x, ty, l) | _ -> raise InvalidPS)
+          | _ -> raise InvalidPS
         in
         let rec aux ps (l : (Var.t * Ty.t) list) =
           match l with
-          | (y, ty) :: (f, ({ e = Arr (_, u, v); _ } as tf)) :: l as l1 ->
-              let fx, fy =
-                try (Tm.to_var u, Tm.to_var v) with IsCoh -> raise Invalid
-              in
-              if y <> fy then raise Invalid;
-              let x, _ = marker ps in
-              if x = fx then (
-                let varps = Ctx.domain (old_rep_to_ctx ps) in
-                if List.mem f varps then raise (DoubledVar (Var.to_string f));
-                if List.mem y varps then raise (DoubledVar (Var.to_string y));
-                let ps = PCons (ps, (y, ty), (f, tf)) in
-                aux ps l)
-              else aux (PDrop ps) l1
-          | _ :: _ :: _ | [ (_, _) ] -> raise Invalid
+          | (y, ty) :: (f, tf) :: l as l1 -> (
+              match Ty.expr tf with
+              | Arr (_, u, v) ->
+                  let fx, fy =
+                    try (Tm.to_var u, Tm.to_var v)
+                    with IsCoh -> raise InvalidPS
+                  in
+                  if y <> fy then raise InvalidPS;
+                  let x, _ = marker ps in
+                  if x = fx then (
+                    let varps = Ctx.domain (old_rep_to_ctx ps) in
+                    if List.mem f varps then
+                      raise (DoubledVar (Var.to_string f));
+                    if List.mem y varps then
+                      raise (DoubledVar (Var.to_string y));
+                    let ps = PCons (ps, (y, ty), (f, tf)) in
+                    aux ps l)
+                  else aux (PDrop ps) l1
+              | _ -> raise InvalidPS)
+          | _ :: [] -> raise InvalidPS
           | [] ->
               let _, tx = marker ps in
               close ps tx
@@ -622,55 +553,72 @@ module Make (Theory : Theory.S) = struct
 
   and Core :
     (CoreSignature.S
-      with type Ty.t = Ty.t
-      with type Coh.t = Coh.t
-      with type Coh.innertm = Tm.t
-      with type Tm.t = Tm.t) = struct
-    module PS = PS
-    module Ty = Ty
-    module Tm = Tm
-    module Coh = Coh
+      with type Ty.t = RTy.t
+       and type Coh.t = RCoh.t
+       and type Tm.t = RTm.t) = struct
+    module PS = RPS
+    module Ty = RTy
+    module Tm = RTm
+    module Coh = RCoh
+
+    type ty = (Coh.t, Tm.t) pty
+    type tm = (Coh.t, Tm.t) ptm
+    type sub = (Coh.t, Tm.t) psub
+    type sub_ps = (Coh.t, Tm.t) psub_ps
+    type ctx = (Coh.t, Tm.t) pctx
+    type constr = (Coh.t, Tm.t) pconstr
+    type meta_ctx = (int * ty) list
+    type value = VCoh of Coh.t | VTm of Tm.t
+    type decls = (value * string) list
   end
 
-  and B : sig
-    exception IsObj
-    exception IsCoh
-    exception InvalidSubTarget of string * string
-    exception MetaVariable
-
-    module rec Sub : sig
-      type t = private {
-        list : Tm.t list;
-        src : Ctx.t;
-        tgt : Ctx.t;
-        unchecked : (Coh.t, Tm.t) sub;
-      }
-
-      val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t
-      val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> Sub.t
-    end
+  and K :
+    (KernelSignature.S
+      with type Coh.t = RCoh.t
+       and type Ty.t = RTy.t
+       and type Tm.t = RTm.t) = struct
+    exception InvalidPS
+
+    module Theory = Theory
+
+    module B : sig
+      open Core
+
+      module Ctx :
+        KernelSignature.CtxS
+          with type checked_ty = Ty.t
+           and type checked_tm = Tm.t
+           and type checked_coh = Coh.t
+           and type checked_ps = PS.t
+
+      module Sub :
+        KernelSignature.SubS
+          with type checked_tm = Tm.t
+           and type checked_coh = Coh.t
+           and type checked_ctx = Ctx.t
+    end =
+      Builder.Make (Core)
+
+    module PS = RPS
+    module Coh = RCoh
+    module Ty = RTy
+    module Tm = RTm
+    module Ctx = B.Ctx
+    module Sub = B.Sub
 
-    and Ctx : sig
-      type t = private {
-        c : (Var.t * Ty.t) list;
-        unchecked : (Coh.t, Tm.t) ctx;
-      }
+    type ty = Core.ty
+    type tm = Core.tm
+    type sub = Core.sub
+    type sub_ps = Core.sub_ps
+    type ctx = Core.ctx
+    type constr = Core.constr
+    type meta_ctx = Core.meta_ctx
+    type value = VCoh of Coh.t | VTm of Tm.t
+    type decls = (value * string) list
+  end
 
-      val to_string : t -> string
-      val ty_var : t -> Var.t -> Ty.t
-      val domain : t -> Var.t list
-      val forget : t -> (Coh.t, Tm.t) ctx
-      val check : (Coh.t, Tm.t) ctx -> t
-      val is_equal : t -> t -> bool
-      val check_equal : t -> t -> unit
-      val of_ps : PS.t -> t
-    end
-  end =
-    Builder.Make (Core)
-
-  module Ctx = B.Ctx
-  module Sub = B.Sub
   include Syntax.Make (Core)
+  include K
 
   let check check_fn name =
     let v = 2 in
@@ -681,7 +629,7 @@ module Make (Theory : Theory.S) = struct
         Error.untypable
           (if !Settings.verbosity >= v then fname else Lazy.force name)
           (Printf.sprintf "%s and %s are not equal" s1 s2)
-    | B.InvalidSubTarget (s, tgt) ->
+    | Builder.InvalidSubTarget (s, tgt) ->
         Error.untypable
           (if !Settings.verbosity >= v then fname else Lazy.force name)
           (Printf.sprintf "substitution %s does not apply from context %s" s tgt)
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index 07f3d66b..26cda6bb 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,108 +1,7 @@
 open Common
 
 module Make (_ : Theory.S) : sig
-  module rec Coh : sig
-    type t
-    type innertm = Tm.t
-
-    val ps : t -> PS.t
-    val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
-    val suspend : t -> t
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val is_inv : t -> bool
-    val to_string : ?unroll:bool -> t -> string
-    val dim : t -> int
-    val src : t -> (Coh.t, Tm.t) tm
-    val tgt : t -> (Coh.t, Tm.t) tm
-    val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
-    val ty : t -> Ty.t
-
-    val check_noninv :
-      ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
-
-    val check_inv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
-
-    val noninv_srctgt :
-      t -> (Coh.t, Tm.t) tm * (Coh.t, Tm.t) tm * (Coh.t, Tm.t) ty
-
-    val func_data : t -> (Var.t * int) list list
-
-    val apply_ps :
-      (ps -> ps) ->
-      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t
-
-    val apply :
-      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) sub
-  end
-
-  and Ty : sig
-    type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty }
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-  end
-
-  and Tm : sig
-    type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t
-
-    and t = private {
-      ty : Ty.t;
-      e : expr;
-      unchecked : (Coh.t, t) tm;
-      mutable developped : (Coh.t, t) tm option;
-      name : pp_data option;
-    }
-
-    val ty : t -> (Coh.t, Tm.t) ty
-    val forget : t -> (Coh.t, Tm.t) tm
-    val constr : t -> (Coh.t, Tm.t) constr
-    val ctx : t -> (Coh.t, Tm.t) ctx
-    val name : t -> string option
-    val full_name : t -> string option
-    val func_data : t -> (Var.t * int) list list option
-    val of_coh : Coh.t -> t
-    val develop : t -> (Coh.t, Tm.t) tm
-    val pp_data : t -> pp_data option
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-
-    val check :
-      (Coh.t, t) ctx -> ?ty:(Coh.t, t) ty -> ?name:pp_data -> (Coh.t, t) tm -> t
-
-    val apply :
-      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-      ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) sub
-  end
-
-  and Sub : sig
-    type t
-  end
-
-  and Ctx : sig
-    type t
-
-    val check : (Coh.t, Tm.t) ctx -> t
-  end
-
-  and PS : sig
-    exception Invalid
-
-    type t = ps
-
-    val mk : Ctx.t -> t
-  end
-
-  module Core : Core.S with type Coh.t = Coh.t with type Tm.t = Tm.t
-  include module type of Syntax.Make (Core)
+  include KernelS
 
   val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
   val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
diff --git a/lib/internals/kernelSignature.mli b/lib/internals/kernelSignature.mli
index bf5df700..042d74e7 100644
--- a/lib/internals/kernelSignature.mli
+++ b/lib/internals/kernelSignature.mli
@@ -1,92 +1,230 @@
 open Common
 
+module type TmS = sig
+  type checked_coh
+  type checked_sub
+  type checked_ty
+  type checked_ctx
+
+  type expr =
+    | Var of Var.t
+    | Coh of checked_coh * checked_sub
+    | App of t * checked_sub
+
+  and t
+
+  val ty : t -> (checked_coh, t) pty
+  val checked_ty : t -> checked_ty
+  val forget : t -> (checked_coh, t) ptm
+  val constr : t -> (checked_coh, t) pconstr
+  val ctx : t -> (checked_coh, t) pctx
+  val name : t -> string option
+  val full_name : t -> string option
+  val func_data : t -> (Var.t * int) list list option
+  val of_coh : checked_coh -> t
+  val preimage : t -> checked_sub -> t
+  val develop : t -> (checked_coh, t) ptm
+  val pp_data : t -> pp_data option
+  val to_string : t -> string
+  val is_equal : t -> t -> bool
+  val apply_sub : t -> checked_sub -> t
+  val to_var : t -> Var.t
+  val expr : t -> expr
+
+  val check_in_ctx :
+    checked_ctx -> ?ty:checked_ty -> ?name:pp_data -> (checked_coh, t) ptm -> t
+
+  val check :
+    (checked_coh, t) pctx ->
+    ?ty:(checked_coh, t) pty ->
+    ?name:pp_data ->
+    (checked_coh, t) ptm ->
+    t
+
+  val apply :
+    ((checked_coh, t) pctx -> (checked_coh, t) pctx) ->
+    ((checked_coh, t) ptm -> (checked_coh, t) ptm) ->
+    (pp_data -> pp_data) ->
+    t ->
+    t * (checked_coh, t) psub
+end
+
+module type CohS = sig
+  type t
+  type innertm
+  type checked_ps
+  type checked_tm
+  type checked_ty
+
+  val ps : t -> checked_ps
+  val forget : t -> ps * (t, checked_tm) pty * pp_data
+  val suspend : t -> t
+  val is_equal : t -> t -> bool
+  val check_equal : t -> t -> unit
+  val is_inv : t -> bool
+  val to_string : ?unroll:bool -> t -> string
+  val dim : t -> int
+  val src : t -> (t, checked_tm) ptm
+  val tgt : t -> (t, checked_tm) ptm
+  val check : ps -> (t, checked_tm) pty -> pp_data -> t
+  val ty : t -> checked_ty
+
+  val check_noninv :
+    ps -> (t, checked_tm) ptm -> (t, checked_tm) ptm -> pp_data -> t
+
+  val check_inv :
+    ps -> (t, checked_tm) ptm -> (t, checked_tm) ptm -> pp_data -> t
+
+  val noninv_srctgt :
+    t -> (t, checked_tm) ptm * (t, checked_tm) ptm * (t, checked_tm) pty
+
+  val func_data : t -> (Var.t * int) list list
+
+  val apply_ps :
+    (ps -> ps) ->
+    ((t, checked_tm) pty -> (t, checked_tm) pty) ->
+    (pp_data -> pp_data) ->
+    t ->
+    t
+
+  val apply :
+    ((t, checked_tm) pctx -> (t, checked_tm) pctx) ->
+    ((t, checked_tm) pty -> (t, checked_tm) pty) ->
+    (pp_data -> pp_data) ->
+    t ->
+    t * (t, checked_tm) psub
+end
+
+module type TyS = sig
+  type checked_tm
+  type checked_coh
+  type checked_ctx
+  type checked_sub
+  type t
+  type expr = Obj | Arr of t * checked_tm * checked_tm
+
+  val check : checked_ctx -> (checked_coh, checked_tm) pty -> t
+  val apply_sub : t -> checked_sub -> t
+  val ctx : t -> checked_ctx
+  val check_equal : t -> t -> unit
+  val morphism : checked_tm -> checked_tm -> t
+  val to_string : t -> string
+  val dim : t -> int
+  val is_equal : t -> t -> bool
+  val forget : t -> (checked_coh, checked_tm) pty
+  val expr : t -> expr
+
+  val check_with_ctx :
+    (checked_coh, checked_tm) pctx -> (checked_coh, checked_tm) pty -> t
+end
+
+module type PSS = sig
+  type t = ps
+  type inner_ctx
+  type checked_sub
+
+  val to_string : t -> string
+  val mk : inner_ctx -> t
+  val source : t -> checked_sub
+  val target : t -> checked_sub
+  val bdry : t -> t
+  val is_equal : t -> t -> bool
+end
+
+module type CtxS = sig
+  type checked_ty
+  type checked_coh
+  type checked_tm
+  type checked_ps
+
+  type t = private {
+    c : (Common.Var.t * checked_ty) list;
+    unchecked : (checked_coh, checked_tm) pctx;
+  }
+
+  val check : (checked_coh, checked_tm) pctx -> t
+  val to_string : t -> string
+  val forget : t -> (checked_coh, checked_tm) pctx
+  val is_equal : t -> t -> bool
+  val check_equal : t -> t -> unit
+  val ty_var : t -> Var.t -> checked_ty
+  val domain : t -> Var.t list
+  val of_ps : checked_ps -> t
+  val check_notin : t -> Var.t -> unit
+  val extend : t -> expl:bool -> Var.t -> (checked_coh, checked_tm) pty -> t
+  val empty : unit -> t
+end
+
+module type SubS = sig
+  type checked_tm
+  type checked_ctx
+  type checked_coh
+
+  type t = private {
+    list : checked_tm list;
+    src : checked_ctx;
+    tgt : checked_ctx;
+    unchecked : (checked_coh, checked_tm) psub;
+  }
+
+  val check : checked_ctx -> (checked_coh, checked_tm) psub -> checked_ctx -> t
+
+  val check_to_ps :
+    checked_ctx -> (checked_coh, checked_tm) psub_ps -> Common.ps -> t
+
+  val forget : t -> (checked_coh, checked_tm) psub
+  val src : t -> checked_ctx
+  val tgt : t -> checked_ctx
+end
+
 module type S = sig
-  module rec Coh : sig
-    type t
-
-    val forget : t -> ps * (Coh.t, Tm.t) ty * pp_data
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val is_inv : t -> bool
-    val to_string : ?unroll:bool -> t -> string
-    val dim : t -> int
-    val src : t -> (Coh.t, Tm.t) tm
-    val tgt : t -> (Coh.t, Tm.t) tm
-    val check : ps -> (Coh.t, Tm.t) ty -> pp_data -> t
-
-    val check_noninv :
-      ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
-
-    val check_inv : ps -> (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm -> pp_data -> t
-
-    val noninv_srctgt :
-      t -> (Coh.t, Tm.t) tm * (Coh.t, Tm.t) tm * (Coh.t, Tm.t) ty
-
-    val func_data : t -> (Var.t * int) list list
-
-    val apply_ps :
-      (ps -> ps) ->
-      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t
-
-    val apply :
-      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-      ((Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) sub
-  end
-
-  and Ty : sig
-    type t
-
-    val forget : t -> (Coh.t, Tm.t) ty
-    val check : Ctx.t -> (Coh.t, Tm.t) ty -> t
-  end
-
-  and Tm : sig
-    type t
-
-    val typ : t -> Ty.t
-    val ty : t -> (Coh.t, Tm.t) ty
-    val forget : t -> (Coh.t, Tm.t) tm
-    val constr : t -> (Coh.t, Tm.t) constr
-    val bdry : t -> t * t
-    val ctx : t -> (Coh.t, Tm.t) ctx
-    val name : t -> string option
-    val full_name : t -> string option
-    val func_data : t -> (Var.t * int) list list option
-    val of_coh : Coh.t -> t
-    val develop : t -> (Coh.t, Tm.t) tm
-    val pp_data : t -> pp_data option
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-
-    val apply :
-      ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) ->
-      ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) sub
-  end
-
-  and Ctx : sig
-    type t
-
-    val check : (Coh.t, Tm.t) ctx -> t
-  end
-
-  module Core : Core.S
-  include module type of Syntax.Make (Core)
-
-  module PS : sig
-    exception Invalid
-
-    type t
-
-    val mk : Ctx.t -> t
-    val forget : t -> ps
-  end
+  exception InvalidPS
+
+  module Theory : Theory.S
+
+  module rec Coh :
+    (CohS
+      with type innertm = Tm.t
+       and type checked_ps = PS.t
+       and type checked_tm = Tm.t
+       and type checked_ty = Ty.t)
+
+  and Ty :
+    (TyS
+      with type checked_tm = Tm.t
+       and type checked_coh = Coh.t
+       and type checked_sub = Sub.t
+       and type checked_ctx = Ctx.t)
+
+  and Tm :
+    (TmS
+      with type checked_coh = Coh.t
+       and type checked_sub = Sub.t
+       and type checked_ty = Ty.t
+       and type checked_ctx = Ctx.t)
+
+  and PS : (PSS with type inner_ctx = Ctx.t and type checked_sub = Sub.t)
+
+  and Ctx :
+    (CtxS
+      with type checked_ty = Ty.t
+       and type checked_coh = Coh.t
+       and type checked_tm = Tm.t
+       and type checked_ps = PS.t)
+
+  and Sub :
+    (SubS
+      with type checked_tm = Tm.t
+       and type checked_coh = Coh.t
+       and type checked_ctx = Ctx.t)
+
+  type ty = (Coh.t, Tm.t) pty
+  type tm = (Coh.t, Tm.t) ptm
+  type sub = (Coh.t, Tm.t) psub
+  type sub_ps = (Coh.t, Tm.t) psub_ps
+  type ctx = (Coh.t, Tm.t) pctx
+  type constr = (Coh.t, Tm.t) pconstr
+  type meta_ctx = (int * ty) list
+  type value = VCoh of Coh.t | VTm of Tm.t
+  type decls = (value * string) list
 end
diff --git a/lib/internals/printing.ml b/lib/internals/printing.ml
index e6357e85..38c85e5b 100644
--- a/lib/internals/printing.ml
+++ b/lib/internals/printing.ml
@@ -1,8 +1,15 @@
 open Common
 
-module Make (Core : Core.S) = struct
-  open Core
-  module Unchecked = Unchecked.Make (Core)
+module Make (C : Core.S) = struct
+  module Unchecked = Unchecked.Make (C)
+  open C
+
+  let rec ps_to_string = function
+    | Br l ->
+        Printf.sprintf "[%s]"
+          (List.fold_left
+             (fun s ps -> Printf.sprintf "%s%s" (ps_to_string ps) s)
+             "" l)
 
   module Regular = struct
     let rec func_to_string func =
@@ -20,14 +27,8 @@ module Make (Core : Core.S) = struct
     let rec bracket i s =
       if i <= 0 then s else Printf.sprintf "[%s]" (bracket (i - 1) s)
 
-    let rec ps_to_string = function
-      | Br l ->
-          Printf.sprintf "[%s]"
-            (List.fold_left
-               (fun s ps -> Printf.sprintf "%s%s" (ps_to_string ps) s)
-               "" l)
-
-    let rec ty_to_string = function
+    let rec ty_to_string ty =
+      match ty with
       | Meta_ty i -> Printf.sprintf "_ty%i" i
       | Obj -> "*"
       | Arr (a, u, v) ->
@@ -36,7 +37,8 @@ module Make (Core : Core.S) = struct
               (tm_to_string v)
           else Printf.sprintf "%s -> %s" (tm_to_string u) (tm_to_string v)
 
-    and tm_to_string = function
+    and tm_to_string x =
+      match x with
       | Var v -> Var.to_string v
       | Meta_tm i -> Printf.sprintf "_tm%i" i
       | Coh (c, s) ->
@@ -355,7 +357,6 @@ module Make (Core : Core.S) = struct
   (*     print_decls decls res *)
   (* end *)
 
-  let ps_to_string = Regular.ps_to_string
   let ty_to_string = Regular.ty_to_string
   let tm_to_string = Regular.tm_to_string
   let ctx_to_string = Regular.ctx_to_string
diff --git a/lib/internals/printing.mli b/lib/internals/printing.mli
index 72d78c17..544ada24 100644
--- a/lib/internals/printing.mli
+++ b/lib/internals/printing.mli
@@ -1,22 +1,17 @@
-module Make (Core : Core.S) : sig
-  open Core
-  open Common
+open Common
 
-  val ps_to_string : ps -> string
-  val ty_to_string : (Coh.t, Tm.t) ty -> string
-  val tm_to_string : (Coh.t, Tm.t) tm -> string
-
-  val sub_ps_to_string :
-    ?func:(Var.t * int) list list -> (Coh.t, Tm.t) sub_ps -> string
-
-  val ctx_to_string : (Coh.t, Tm.t) ctx -> string
+module Make (C : Core.S) : sig
+  open C
 
-  val sub_to_string :
-    ?func:(Var.t * int) list list -> (Coh.t, Tm.t) sub -> string
-
-  val sub_to_string_debug : (Coh.t, Tm.t) sub -> string
-  val meta_ctx_to_string : (Coh.t, Tm.t) meta_ctx -> string
+  val ps_to_string : ps -> string
+  val ty_to_string : ty -> string
+  val tm_to_string : tm -> string
+  val sub_ps_to_string : ?func:(Var.t * int) list list -> sub_ps -> string
+  val ctx_to_string : ctx -> string
+  val sub_to_string : ?func:(Var.t * int) list list -> sub -> string
+  val sub_to_string_debug : sub -> string
+  val meta_ctx_to_string : meta_ctx -> string
   val full_name : pp_data -> string
   val pp_data_to_string : ?print_func:bool -> pp_data -> string
-  val print_kolmogorov : (Coh.t, Tm.t) tm -> string
+  val print_kolmogorov : tm -> string
 end
diff --git a/lib/internals/syntax.ml b/lib/internals/syntax.ml
index 5b03c1e4..07304e23 100644
--- a/lib/internals/syntax.ml
+++ b/lib/internals/syntax.ml
@@ -1,16 +1,6 @@
-module Make (Core : Core.S) = struct
-  open Core
-
-  type ty = (Coh.t, Tm.t) Common.ty
-  type tm = (Coh.t, Tm.t) Common.tm
-  type sub_ps = (Coh.t, Tm.t) Common.sub_ps
-  type sub = (Coh.t, Tm.t) Common.sub
-  type ctx = (Coh.t, Tm.t) Common.ctx
-  type meta_ctx = (Coh.t, Tm.t) Common.meta_ctx
-  type constr = (Coh.t, Tm.t) Common.constr
-
-  module Unchecked = Unchecked.Make (Core)
-  module Display_maps = Display_maps.Make (Core)
-  module Printing = Printing.Make (Core)
-  module Equality = Equality.Make (Core)
+module Make (C : Core.S) = struct
+  module Unchecked = Unchecked.Make (C)
+  module Display_maps = Display_maps.Make (C)
+  module Printing = Printing.Make (C)
+  module Equality = Equality.Make (C)
 end
diff --git a/lib/internals/syntax.mli b/lib/internals/syntax.mli
index 471e4cea..c8df08d7 100644
--- a/lib/internals/syntax.mli
+++ b/lib/internals/syntax.mli
@@ -1,16 +1,6 @@
-module Make : functor (Core : Core.S) -> sig
-  open Core
-
-  type ty = (Coh.t, Tm.t) Common.ty
-  type tm = (Coh.t, Tm.t) Common.tm
-  type sub_ps = (Coh.t, Tm.t) Common.sub_ps
-  type sub = (Coh.t, Tm.t) Common.sub
-  type ctx = (Coh.t, Tm.t) Common.ctx
-  type meta_ctx = (Coh.t, Tm.t) Common.meta_ctx
-  type constr = (Coh.t, Tm.t) Common.constr
-
-  module Unchecked : module type of Unchecked.Make (Core)
-  module Display_maps : module type of Display_maps.Make (Core)
-  module Printing : module type of Printing.Make (Core)
-  module Equality : module type of Equality.Make (Core)
+module Make : functor (C : Core.S) -> sig
+  module Unchecked : module type of Unchecked.Make (C)
+  module Display_maps : module type of Display_maps.Make (C)
+  module Printing : module type of Printing.Make (C)
+  module Equality : module type of Equality.Make (C)
 end
diff --git a/lib/internals/unchecked.ml b/lib/internals/unchecked.ml
index 7da9efb2..6d085123 100644
--- a/lib/internals/unchecked.ml
+++ b/lib/internals/unchecked.ml
@@ -1,8 +1,8 @@
 open Std
 open Common
 
-module Make (Core : Core.S) = struct
-  open Core
+module Make (C : Core.S) = struct
+  open C
 
   let sub_ps_to_sub s =
     let rec aux s =
@@ -112,13 +112,8 @@ module Make (Core : Core.S) = struct
          maximal variable.
     *)
 
-  type ctx_bp = { ctx : (Coh.t, Tm.t) ctx; max : int; rp : int }
-
-  type sub_ps_bp = {
-    sub_ps : (Coh.t, Tm.t) sub_ps;
-    l : (Coh.t, Tm.t) tm;
-    r : (Coh.t, Tm.t) tm;
-  }
+  type ctx_bp = { ctx : ctx; max : int; rp : int }
+  type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
 
   let suspend_ps ps = Br [ ps ]
 
@@ -259,7 +254,7 @@ module Make (Core : Core.S) = struct
     let incls, _ = canonical_inclusions l in
     incls
 
-  let tbl_ps_to_ctx : (ps, (Coh.t, Tm.t) ctx) Hashtbl.t = Hashtbl.create 7829
+  let tbl_ps_to_ctx : (ps, ctx) Hashtbl.t = Hashtbl.create 7829
 
   let ps_to_ctx ps =
     match Hashtbl.find_opt tbl_ps_to_ctx ps with
diff --git a/lib/internals/unchecked.mli b/lib/internals/unchecked.mli
index e0f3c41e..03251de7 100644
--- a/lib/internals/unchecked.mli
+++ b/lib/internals/unchecked.mli
@@ -1,119 +1,66 @@
-module Make (Core : Core.S) : sig
-  open Core
-  open Common
+open Common
 
-  type sub_ps_bp = {
-    sub_ps : (Coh.t, Tm.t) sub_ps;
-    l : (Coh.t, Tm.t) tm;
-    r : (Coh.t, Tm.t) tm;
-  }
+module Make (C : Core.S) : sig
+  open C
 
-  val dim_ctx : (Coh.t, Tm.t) ctx -> int
-  val dim_ty : (Coh.t, Tm.t) ty -> int
-  val dim_ps : ps -> int
-  val ps_to_ctx : ps -> (Coh.t, Tm.t) ctx
-  val identity_ps : ps -> (Coh.t, Tm.t) sub_ps
-  val tm_apply_sub : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) tm
-  val ty_apply_sub : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) ty
-
-  val sub_apply_sub :
-    (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub
-
-  val sub_ps_apply_sub :
-    (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub_ps
-
-  val ty_apply_sub_ps :
-    (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) ty
-
-  val tm_apply_sub_ps :
-    (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) tm
-
-  val sub_ps_apply_sub_ps :
-    (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps
-
-  val ty_rename :
-    (Coh.t, Tm.t) ty -> (Var.t * (Coh.t, Tm.t) tm) list -> (Coh.t, Tm.t) ty
-
-  val tm_rename :
-    (Coh.t, Tm.t) tm -> (Var.t * (Coh.t, Tm.t) tm) list -> (Coh.t, Tm.t) tm
-
-  val sub_ps_rename :
-    (Coh.t, Tm.t) sub_ps ->
-    (Var.t * (Coh.t, Tm.t) tm) list ->
-    (Coh.t, Tm.t) sub_ps
-
-  val ty_sub_preimage :
-    (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) ty
-
-  val db_levels :
-    (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx * (Var.t * (int * bool)) list * int
-
-  val db_level_sub : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
-  val db_level_sub_inv : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
-
-  val rename_ty :
-    (Coh.t, Tm.t) ty -> (Var.t * (int * bool)) list -> (Coh.t, Tm.t) ty
+  type sub_ps_bp = { sub_ps : sub_ps; l : tm; r : tm }
 
-  val rename_tm :
-    (Coh.t, Tm.t) tm -> (Var.t * (int * bool)) list -> (Coh.t, Tm.t) tm
-
-  val tm_contains_var : (Coh.t, Tm.t) tm -> Var.t -> bool
-  val ty_contains_var : (Coh.t, Tm.t) ty -> Var.t -> bool
-  val tm_contains_vars : (Coh.t, Tm.t) tm -> Var.t list -> bool
-  val sub_ps_to_sub : (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub
-  val sub_to_sub_ps : (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub_ps
+  val dim_ctx : ctx -> int
+  val dim_ty : ty -> int
+  val dim_ps : ps -> int
+  val ps_to_ctx : ps -> ctx
+  val identity_ps : ps -> sub_ps
+  val tm_apply_sub : tm -> sub -> tm
+  val ty_apply_sub : ty -> sub -> ty
+  val sub_apply_sub : sub -> sub -> sub
+  val sub_ps_apply_sub : sub_ps -> sub -> sub_ps
+  val ty_apply_sub_ps : ty -> sub_ps -> ty
+  val tm_apply_sub_ps : tm -> sub_ps -> tm
+  val sub_ps_apply_sub_ps : sub_ps -> sub_ps -> sub_ps
+  val ty_rename : ty -> (Var.t * tm) list -> ty
+  val tm_rename : tm -> (Var.t * tm) list -> tm
+  val sub_ps_rename : sub_ps -> (Var.t * tm) list -> sub_ps
+  val ty_sub_preimage : ty -> sub -> ty
+  val db_levels : ctx -> ctx * (Var.t * (int * bool)) list * int
+  val db_level_sub : ctx -> sub
+  val db_level_sub_inv : ctx -> sub
+  val rename_ty : ty -> (Var.t * (int * bool)) list -> ty
+  val rename_tm : tm -> (Var.t * (int * bool)) list -> tm
+  val tm_contains_var : tm -> Var.t -> bool
+  val ty_contains_var : ty -> Var.t -> bool
+  val tm_contains_vars : tm -> Var.t list -> bool
+  val sub_ps_to_sub : sub_ps -> sub
+  val sub_to_sub_ps : sub -> sub_ps
   val suspend_pp_data : pp_data -> pp_data
   val suspend_ps : ps -> ps
-  val suspend_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty
-  val suspend_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm
-  val suspend_ctx : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx
-  val suspend_sub_ps : (Coh.t, Tm.t) sub_ps -> (Coh.t, Tm.t) sub_ps
-  val suspend_sub : (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) sub
+  val suspend_ty : ty -> ty
+  val suspend_tm : tm -> tm
+  val suspend_ctx : ctx -> ctx
+  val suspend_sub_ps : sub_ps -> sub_ps
+  val suspend_sub : sub -> sub
   val ps_bdry : ps -> ps
-  val ps_src : ps -> (Coh.t, Tm.t) sub_ps
-  val ps_tgt : ps -> (Coh.t, Tm.t) sub_ps
-
-  val tm_sub_preimage :
-    (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) sub -> (Coh.t, Tm.t) tm
-
-  val suspwedge_subs_ps :
-    (Coh.t, Tm.t) sub_ps list -> ps list -> (Coh.t, Tm.t) sub_ps
-
-  val opsuspwedge_subs_ps :
-    (Coh.t, Tm.t) sub_ps list -> ps list -> (Coh.t, Tm.t) sub_ps
-
-  val canonical_inclusions : ps list -> (Coh.t, Tm.t) sub_ps list
-  val ty_to_sub_ps : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) sub_ps
-  val coh_to_sub_ps : (Coh.t, Coh.innertm) tm -> (Coh.t, Coh.innertm) sub_ps
-
-  val ps_compose :
-    int -> ps -> ps -> ps * (Coh.t, Tm.t) sub_ps * (Coh.t, Tm.t) sub_ps
-
-  val pullback_up :
-    int ->
-    ps ->
-    ps ->
-    (Coh.t, Tm.t) sub_ps ->
-    (Coh.t, Tm.t) sub_ps ->
-    (Coh.t, Tm.t) sub_ps
-
-  val sub_ps_to_sub_ps_bp : (Coh.t, Tm.t) sub_ps -> sub_ps_bp
-  val wedge_sub_ps_bp : sub_ps_bp list -> (Coh.t, Tm.t) sub_ps
-
-  val list_to_sub :
-    (Coh.t, Tm.t) tm list -> (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
-
-  val list_to_db_level_sub :
-    (Coh.t, Tm.t) tm list -> (Var.t * (Coh.t, Tm.t) tm) list
-
-  val identity : (Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) sub
+  val ps_src : ps -> sub_ps
+  val ps_tgt : ps -> sub_ps
+  val tm_sub_preimage : tm -> sub -> tm
+  val suspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
+  val opsuspwedge_subs_ps : sub_ps list -> ps list -> sub_ps
+  val canonical_inclusions : ps list -> sub_ps list
+  val ty_to_sub_ps : ty -> sub_ps
+  val coh_to_sub_ps : tm -> sub_ps
+  val ps_compose : int -> ps -> ps -> ps * sub_ps * sub_ps
+  val pullback_up : int -> ps -> ps -> sub_ps -> sub_ps -> sub_ps
+  val sub_ps_to_sub_ps_bp : sub_ps -> sub_ps_bp
+  val wedge_sub_ps_bp : sub_ps_bp list -> sub_ps
+  val list_to_sub : tm list -> ctx -> sub
+  val list_to_db_level_sub : tm list -> (Var.t * tm) list
+  val identity : ctx -> sub
   val disc : int -> ps
-  val disc_ctx : int -> (Coh.t, Tm.t) ctx
-  val disc_type : int -> (Coh.t, Tm.t) ty
-  val sphere : int -> (Coh.t, Tm.t) ctx
-  val sphere_inc : int -> (Coh.t, Tm.t) sub
-  val disc_src : int -> (Coh.t, Tm.t) sub_ps
-  val disc_tgt : int -> (Coh.t, Tm.t) sub_ps
-  val develop_tm : (Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm
-  val develop_ty : (Coh.t, Tm.t) ty -> (Coh.t, Tm.t) ty
+  val disc_ctx : int -> ctx
+  val disc_type : int -> ty
+  val sphere : int -> ctx
+  val sphere_inc : int -> sub
+  val disc_src : int -> sub_ps
+  val disc_tgt : int -> sub_ps
+  val develop_tm : tm -> tm
+  val develop_ty : ty -> ty
 end
diff --git a/lib/lib/common.ml b/lib/lib/common.ml
index c5a74bc0..ef236791 100644
--- a/lib/lib/common.ml
+++ b/lib/lib/common.ml
@@ -47,28 +47,261 @@ module Var = struct
     fresh
 end
 
-type ('a, 'b) ty =
+type pp_data = string * int * (Var.t * int) list list
+
+(* module type KernelS = sig *)
+(*   type tm *)
+(*   type ty *)
+(*   type ctx *)
+(*   type sub *)
+(*   type sub_ps *)
+(*   type constr *)
+
+(*   module rec Coh : sig *)
+(*     type t *)
+(*     type innertm = Tm.t *)
+
+(*     val ps : t -> PS.t *)
+(*     val forget : t -> ps * ty * pp_data *)
+(*     val suspend : t -> t *)
+(*     val is_equal : t -> t -> bool *)
+(*     val check_equal : t -> t -> unit *)
+(*     val is_inv : t -> bool *)
+(*     val to_string : ?unroll:bool -> t -> string *)
+(*     val dim : t -> int *)
+(*     val src : t -> tm *)
+(*     val tgt : t -> tm *)
+(*     val check : ps -> ty -> pp_data -> t *)
+(*     val ty : t -> Ty.t *)
+(*     val check_noninv : ps -> tm -> tm -> pp_data -> t *)
+(*     val check_inv : ps -> tm -> tm -> pp_data -> t *)
+(*     val noninv_srctgt : t -> tm * tm * ty *)
+(*     val func_data : t -> (Var.t * int) list list *)
+(*     val apply_ps : (ps -> ps) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t *)
+
+(*     val apply : *)
+(*       (ctx -> ctx) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t * sub *)
+(*   end *)
+
+(*   and Ty : sig *)
+(*     type t = private { c : Ctx.t; e : expr; unchecked : ty } *)
+(*     and expr = Obj | Arr of t * Tm.t * Tm.t *)
+(*   end *)
+
+(*   and Tm : sig *)
+(*     type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t *)
+(*     and t *)
+
+(*     val ty : t -> ty *)
+(*     val forget : t -> tm *)
+(*     val constr : t -> constr *)
+(*     val ctx : t -> ctx *)
+(*     val name : t -> string option *)
+(*     val full_name : t -> string option *)
+(*     val func_data : t -> (Var.t * int) list list option *)
+(*     val of_coh : Coh.t -> t *)
+(*     val develop : t -> tm *)
+(*     val pp_data : t -> pp_data option *)
+(*     val to_string : t -> string *)
+(*     val is_equal : t -> t -> bool *)
+(*     val check : ctx -> ?ty:ty -> ?name:pp_data -> tm -> t *)
+
+(*     val apply : *)
+(*       (ctx -> ctx) -> (tm -> tm) -> (pp_data -> pp_data) -> t -> t * sub *)
+(*   end *)
+
+(*   and Sub : sig *)
+(*     type t *)
+(*   end *)
+
+(*   and Ctx : sig *)
+(*     type t *)
+
+(*     val check : ctx -> t *)
+(*   end *)
+
+(*   and PS : sig *)
+(*     exception Invalid *)
+
+(*     type t = ps *)
+
+(*     val mk : Ctx.t -> t *)
+(*   end *)
+(* end *)
+
+(* module type SyntaxS = sig *)
+(*   type checked_tm *)
+(*   type checked_coh *)
+
+(*   type ty = Meta_ty of int | Obj | Arr of ty * tm * tm *)
+
+(*   and tm = *)
+(*     | Var : Var.t -> tm *)
+(*     | Meta_tm : int -> tm *)
+(*     | Coh : *)
+(*         (module KernelS *)
+(*            with type tm = tm *)
+(*             and type ty = ty *)
+(*             and type ctx = ctx *)
+(*             and type sub = sub *)
+(*             and type sub_ps = sub_ps *)
+(*             and type constr = constr *)
+(*             and type Coh.t = checked_coh *)
+(*             and type Tm.t = checked_tm) *)
+(*         * checked_coh *)
+(*         * sub_ps *)
+(*         -> tm *)
+(*     | App : *)
+(*         (module KernelS *)
+(*            with type tm = tm *)
+(*             and type ty = ty *)
+(*             and type ctx = ctx *)
+(*             and type sub = sub *)
+(*             and type sub_ps = sub_ps *)
+(*             and type constr = constr *)
+(*             and type Coh.t = checked_coh *)
+(*             and type Tm.t = checked_tm) *)
+(*         * checked_tm *)
+(*         * sub *)
+(*         -> tm *)
+
+(*   and sub_ps = (tm * bool) list *)
+(*   and sub = (Var.t * (tm * bool)) list *)
+(*   and ctx = (Var.t * (ty * bool)) list *)
+(*   and constr = tm * ty *)
+
+(*   type meta_ctx = (int * ty) list *)
+(*   type value = VCoh of checked_coh | VTm of checked_tm *)
+(*   type decls = (value * string) list *)
+(* end *)
+
+type ('a, 'b) pty =
   | Meta_ty of int
   | Obj
-  | Arr of ('a, 'b) ty * ('a, 'b) tm * ('a, 'b) tm
+  | Arr of ('a, 'b) pty * ('a, 'b) ptm * ('a, 'b) ptm
 
-and ('a, 'b) tm =
+and ('a, 'b) ptm =
   | Var of Var.t
   | Meta_tm of int
-  | Coh of 'a * ('a, 'b) sub_ps
-  | App of 'b * ('a, 'b) sub
+  | Coh of 'a * ('a, 'b) psub_ps
+  | App of 'b * ('a, 'b) psub
 
-and ('a, 'b) sub_ps = (('a, 'b) tm * bool) list
-and ('a, 'b) sub = (Var.t * (('a, 'b) tm * bool)) list
+and ('a, 'b) psub_ps = (('a, 'b) ptm * bool) list
+and ('a, 'b) psub = (Var.t * (('a, 'b) ptm * bool)) list
 
-type ('a, 'b) ctx = (Var.t * (('a, 'b) ty * bool)) list
-type ('a, 'b) meta_ctx = (int * ('a, 'b) ty) list
-type ('a, 'b) constr = ('a, 'b) tm * ('a, 'b) ty
-type ('a, 'b) value = VCoh of 'a | VTm of 'b
-type ('a, 'b) decls = (('a, 'b) value * string) list
+type ('a, 'b) pctx = (Var.t * (('a, 'b) pty * bool)) list
+type ('a, 'b) pconstr = ('a, 'b) ptm * ('a, 'b) pty
 
-(* For application *)
-type pp_data = string * int * (Var.t * int) list list
+module type KernelS = sig
+  module rec Coh : sig
+    type t
+    type innertm = Tm.t
+
+    val ps : t -> PS.t
+    val forget : t -> ps * (Coh.t, Tm.t) pty * pp_data
+    val suspend : t -> t
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val is_inv : t -> bool
+    val to_string : ?unroll:bool -> t -> string
+    val dim : t -> int
+    val src : t -> (Coh.t, Tm.t) ptm
+    val tgt : t -> (Coh.t, Tm.t) ptm
+    val check : ps -> (Coh.t, Tm.t) pty -> pp_data -> t
+    val ty : t -> Ty.t
+
+    val check_noninv :
+      ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
+
+    val check_inv : ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
+
+    val noninv_srctgt :
+      t -> (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) pty
+
+    val func_data : t -> (Var.t * int) list list
+
+    val apply_ps :
+      (ps -> ps) ->
+      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
+      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) psub
+  end
+
+  and Ty : sig
+    type t
+    and expr = Obj | Arr of t * Tm.t * Tm.t
+  end
+
+  and Tm : sig
+    type t
+
+    val ty : t -> (Coh.t, Tm.t) pty
+    val forget : t -> (Coh.t, Tm.t) ptm
+    val constr : t -> (Coh.t, Tm.t) pconstr
+    val ctx : t -> (Coh.t, Tm.t) pctx
+    val name : t -> string option
+    val full_name : t -> string option
+    val func_data : t -> (Var.t * int) list list option
+    val of_coh : Coh.t -> t
+    val develop : t -> (Coh.t, Tm.t) ptm
+    val pp_data : t -> pp_data option
+    val to_string : t -> string
+    val is_equal : t -> t -> bool
+
+    val check :
+      (Coh.t, Tm.t) pctx ->
+      ?ty:(Coh.t, Tm.t) pty ->
+      ?name:pp_data ->
+      (Coh.t, Tm.t) ptm ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
+      ((Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) psub
+  end
+
+  and PS : sig
+    type t = ps
+    type inner_ctx
+
+    val mk : inner_ctx -> t
+  end
+
+  module Ctx : sig
+    type t
+
+    val check : (Coh.t, Tm.t) pctx -> t
+    val to_string : t -> string
+    val forget : t -> (Coh.t, Tm.t) pctx
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+  end
+
+  module Sub : sig
+    type t
+  end
+
+  type ty = (Coh.t, Tm.t) pty
+  type tm = (Coh.t, Tm.t) ptm
+  type sub = (Coh.t, Tm.t) psub
+  type sub_ps = (Coh.t, Tm.t) psub_ps
+  type ctx = (Coh.t, Tm.t) pctx
+  type constr = (Coh.t, Tm.t) pconstr
+  type meta_ctx = (int * ty) list
+  type value = VCoh of Coh.t | VTm of Tm.t
+  type decls = (value * string) list
+end
 
 let rec take n l =
   match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
diff --git a/lib/lib/common.mli b/lib/lib/common.mli
index 35aae4c7..4f098a95 100644
--- a/lib/lib/common.mli
+++ b/lib/lib/common.mli
@@ -21,26 +21,261 @@ module Var : sig
   val fresh : unit -> t
 end
 
-type ('a, 'b) ty =
+type pp_data = string * int * (Var.t * int) list list
+
+(* module type KernelS = sig *)
+(*   type tm *)
+(*   type ty *)
+(*   type ctx *)
+(*   type sub *)
+(*   type sub_ps *)
+(*   type constr *)
+
+(*   module rec Coh : sig *)
+(*     type t *)
+(*     type innertm = Tm.t *)
+
+(*     val ps : t -> PS.t *)
+(*     val forget : t -> ps * ty * pp_data *)
+(*     val suspend : t -> t *)
+(*     val is_equal : t -> t -> bool *)
+(*     val check_equal : t -> t -> unit *)
+(*     val is_inv : t -> bool *)
+(*     val to_string : ?unroll:bool -> t -> string *)
+(*     val dim : t -> int *)
+(*     val src : t -> tm *)
+(*     val tgt : t -> tm *)
+(*     val check : ps -> ty -> pp_data -> t *)
+(*     val ty : t -> Ty.t *)
+(*     val check_noninv : ps -> tm -> tm -> pp_data -> t *)
+(*     val check_inv : ps -> tm -> tm -> pp_data -> t *)
+(*     val noninv_srctgt : t -> tm * tm * ty *)
+(*     val func_data : t -> (Var.t * int) list list *)
+(*     val apply_ps : (ps -> ps) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t *)
+
+(*     val apply : *)
+(*       (ctx -> ctx) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t * sub *)
+(*   end *)
+
+(*   and Ty : sig *)
+(*     type t = private { c : Ctx.t; e : expr; unchecked : ty } *)
+(*     and expr = Obj | Arr of t * Tm.t * Tm.t *)
+(*   end *)
+
+(*   and Tm : sig *)
+(*     type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t *)
+(*     and t *)
+
+(*     val ty : t -> ty *)
+(*     val forget : t -> tm *)
+(*     val constr : t -> constr *)
+(*     val ctx : t -> ctx *)
+(*     val name : t -> string option *)
+(*     val full_name : t -> string option *)
+(*     val func_data : t -> (Var.t * int) list list option *)
+(*     val of_coh : Coh.t -> t *)
+(*     val develop : t -> tm *)
+(*     val pp_data : t -> pp_data option *)
+(*     val to_string : t -> string *)
+(*     val is_equal : t -> t -> bool *)
+(*     val check : ctx -> ?ty:ty -> ?name:pp_data -> tm -> t *)
+
+(*     val apply : *)
+(*       (ctx -> ctx) -> (tm -> tm) -> (pp_data -> pp_data) -> t -> t * sub *)
+(*   end *)
+
+(*   and Sub : sig *)
+(*     type t *)
+(*   end *)
+
+(*   and Ctx : sig *)
+(*     type t *)
+
+(*     val check : ctx -> t *)
+(*   end *)
+
+(*   and PS : sig *)
+(*     exception Invalid *)
+
+(*     type t = ps *)
+
+(*     val mk : Ctx.t -> t *)
+(*   end *)
+(* end *)
+
+(* module type SyntaxS = sig *)
+(*   type checked_tm *)
+(*   type checked_coh *)
+
+(*   type ty = Meta_ty of int | Obj | Arr of ty * tm * tm *)
+
+(*   and tm = *)
+(*     | Var : Var.t -> tm *)
+(*     | Meta_tm : int -> tm *)
+(*     | Coh : *)
+(*         (module KernelS *)
+(*            with type tm = tm *)
+(*             and type ty = ty *)
+(*             and type ctx = ctx *)
+(*             and type sub = sub *)
+(*             and type sub_ps = sub_ps *)
+(*             and type constr = constr *)
+(*             and type Coh.t = checked_coh *)
+(*             and type Tm.t = checked_tm) *)
+(*         * checked_coh *)
+(*         * sub_ps *)
+(*         -> tm *)
+(*     | App : *)
+(*         (module KernelS *)
+(*            with type tm = tm *)
+(*             and type ty = ty *)
+(*             and type ctx = ctx *)
+(*             and type sub = sub *)
+(*             and type sub_ps = sub_ps *)
+(*             and type constr = constr *)
+(*             and type Coh.t = checked_coh *)
+(*             and type Tm.t = checked_tm) *)
+(*         * checked_tm *)
+(*         * sub *)
+(*         -> tm *)
+
+(*   and sub_ps = (tm * bool) list *)
+(*   and sub = (Var.t * (tm * bool)) list *)
+(*   and ctx = (Var.t * (ty * bool)) list *)
+(*   and constr = tm * ty *)
+
+(*   type meta_ctx = (int * ty) list *)
+(*   type value = VCoh of checked_coh | VTm of checked_tm *)
+(*   type decls = (value * string) list *)
+(* end *)
+
+type ('a, 'b) pty =
   | Meta_ty of int
   | Obj
-  | Arr of ('a, 'b) ty * ('a, 'b) tm * ('a, 'b) tm
+  | Arr of ('a, 'b) pty * ('a, 'b) ptm * ('a, 'b) ptm
 
-and ('a, 'b) tm =
+and ('a, 'b) ptm =
   | Var of Var.t
   | Meta_tm of int
-  | Coh of 'a * ('a, 'b) sub_ps
-  | App of 'b * ('a, 'b) sub
+  | Coh of 'a * ('a, 'b) psub_ps
+  | App of 'b * ('a, 'b) psub
 
-and ('a, 'b) sub_ps = (('a, 'b) tm * bool) list
-and ('a, 'b) sub = (Var.t * (('a, 'b) tm * bool)) list
+and ('a, 'b) psub_ps = (('a, 'b) ptm * bool) list
+and ('a, 'b) psub = (Var.t * (('a, 'b) ptm * bool)) list
 
-type ('a, 'b) ctx = (Var.t * (('a, 'b) ty * bool)) list
-type ('a, 'b) meta_ctx = (int * ('a, 'b) ty) list
-type ('a, 'b) constr = ('a, 'b) tm * ('a, 'b) ty
-type pp_data = string * int * (Var.t * int) list list
-type ('a, 'b) value = VCoh of 'a | VTm of 'b
-type ('a, 'b) decls = (('a, 'b) value * string) list
+type ('a, 'b) pctx = (Var.t * (('a, 'b) pty * bool)) list
+type ('a, 'b) pconstr = ('a, 'b) ptm * ('a, 'b) pty
+
+module type KernelS = sig
+  module rec Coh : sig
+    type t
+    type innertm = Tm.t
+
+    val ps : t -> PS.t
+    val forget : t -> ps * (Coh.t, Tm.t) pty * pp_data
+    val suspend : t -> t
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val is_inv : t -> bool
+    val to_string : ?unroll:bool -> t -> string
+    val dim : t -> int
+    val src : t -> (Coh.t, Tm.t) ptm
+    val tgt : t -> (Coh.t, Tm.t) ptm
+    val check : ps -> (Coh.t, Tm.t) pty -> pp_data -> t
+    val ty : t -> Ty.t
+
+    val check_noninv :
+      ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
+
+    val check_inv : ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
+
+    val noninv_srctgt :
+      t -> (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) pty
+
+    val func_data : t -> (Var.t * int) list list
+
+    val apply_ps :
+      (ps -> ps) ->
+      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
+      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) psub
+  end
+
+  and Ty : sig
+    type t
+    and expr = Obj | Arr of t * Tm.t * Tm.t
+  end
+
+  and Tm : sig
+    type t
+
+    val ty : t -> (Coh.t, Tm.t) pty
+    val forget : t -> (Coh.t, Tm.t) ptm
+    val constr : t -> (Coh.t, Tm.t) pconstr
+    val ctx : t -> (Coh.t, Tm.t) pctx
+    val name : t -> string option
+    val full_name : t -> string option
+    val func_data : t -> (Var.t * int) list list option
+    val of_coh : Coh.t -> t
+    val develop : t -> (Coh.t, Tm.t) ptm
+    val pp_data : t -> pp_data option
+    val to_string : t -> string
+    val is_equal : t -> t -> bool
+
+    val check :
+      (Coh.t, Tm.t) pctx ->
+      ?ty:(Coh.t, Tm.t) pty ->
+      ?name:pp_data ->
+      (Coh.t, Tm.t) ptm ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
+      ((Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) psub
+  end
+
+  and PS : sig
+    type t = ps
+    type inner_ctx
+
+    val mk : inner_ctx -> t
+  end
+
+  module Ctx : sig
+    type t
+
+    val check : (Coh.t, Tm.t) pctx -> t
+    val to_string : t -> string
+    val forget : t -> (Coh.t, Tm.t) pctx
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+  end
+
+  module Sub : sig
+    type t
+  end
+
+  type ty = (Coh.t, Tm.t) pty
+  type tm = (Coh.t, Tm.t) ptm
+  type sub = (Coh.t, Tm.t) psub
+  type sub_ps = (Coh.t, Tm.t) psub_ps
+  type ctx = (Coh.t, Tm.t) pctx
+  type constr = (Coh.t, Tm.t) pconstr
+  type meta_ctx = (int * ty) list
+  type value = VCoh of Coh.t | VTm of Tm.t
+  type decls = (value * string) list
+end
 
 val take : int -> 'a list -> 'a list
 
diff --git a/lib/meta_operations/builtin.ml b/lib/meta_operations/builtin.ml
index b222f2be..076f3f88 100644
--- a/lib/meta_operations/builtin.ml
+++ b/lib/meta_operations/builtin.ml
@@ -6,6 +6,8 @@ module Make (Theory : Theory.S) = struct
   module Suspension = Suspension.Make (Theory)
   module Functorialisation = Functorialisation.Make (Theory)
 
+  let mod_coh = assert false
+
   let id _ =
     check_coh (Br []) (Arr (Obj, Var (Db 0), Var (Db 0))) ("builtin_id", 0, [])
 
@@ -22,7 +24,7 @@ module Make (Theory : Theory.S) = struct
       match l with
       | [] -> [ (t, false) ]
       | Br [] :: l ->
-          (Coh (id (), [ (t, true) ]), true) :: (t, false) :: id_map l
+          (Coh (mod_coh, id (), [ (t, true) ]), true) :: (t, false) :: id_map l
       | _ -> Error.fatal "identity must be inserted on maximal argument"
     in
     let rec aux i ps =
@@ -53,12 +55,14 @@ module Make (Theory : Theory.S) = struct
     let bdry = Unchecked.ps_bdry ps in
     let src =
       let coh = Coh.check_noninv ps t t ("endo", 0, []) in
-      Coh (coh, id_all_max ps)
+      Coh (mod_coh, coh, id_all_max ps)
     in
     let a = Tm.ty (check_term (Ctx.check (Unchecked.ps_to_ctx bdry)) t) in
     let da = Unchecked.dim_ty a in
     let sub_base = Unchecked.ty_to_sub_ps a in
-    let tgt = Coh (Suspension.coh (Some da) (id ()), (t, true) :: sub_base) in
+    let tgt =
+      Coh (mod_coh, Suspension.coh (Some da) (id ()), (t, true) :: sub_base)
+    in
     Coh.check_inv bdry src tgt ("unbiased_unitor", 0, [])
 
   let tdb i = Var (Var.Db i)
diff --git a/lib/meta_operations/comp.ml b/lib/meta_operations/comp.ml
index 0bb3324f..b6fc4728 100644
--- a/lib/meta_operations/comp.ml
+++ b/lib/meta_operations/comp.ml
@@ -38,5 +38,7 @@ module Make (Theory : Theory.S) = struct
   let bcomp x y f z g =
     let comp = comp_n 2 in
     let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
-    Coh (comp, sub)
+    (* TODO *)
+    let mod_coh = assert false in
+    Coh (mod_coh, comp, sub)
 end
diff --git a/lib/meta_operations/cones.ml b/lib/meta_operations/cones.ml
index 2eaf7f51..644f30ea 100644
--- a/lib/meta_operations/cones.ml
+++ b/lib/meta_operations/cones.ml
@@ -8,6 +8,8 @@ module Make (Theory : Theory.S) = struct
   module Suspension = Suspension.Make (Theory)
   module Functorialisation = Functorialisation.Make (Theory)
 
+  let mod_coh = assert false
+  let mod_tm = assert false
   let wcomp = Construct.wcomp
 
   (* Cone contexts *)
@@ -215,7 +217,7 @@ module Make (Theory : Theory.S) = struct
       let assoc = Builtin.assoc in
       let _, assoc_ty, _ = Coh.forget assoc in
       let tm_2 =
-        ( Coh (Builtin.assoc, sub_ps),
+        ( Coh (mod_coh, Builtin.assoc, sub_ps),
           Unchecked.ty_apply_sub assoc_ty (Unchecked.sub_ps_to_sub sub_ps) )
       in
       let tm, _ = wcomp tm_1 1 tm_2 in
@@ -278,7 +280,7 @@ module Make (Theory : Theory.S) = struct
                    (Opposite.sub (Cone.bdry_left (n - 1) (n - 2)) op_data))
             in
             check_term (Ctx.check ctx_comp) ~name:(name, 0, [])
-              (App (comp, sub))
+              (App (mod_tm, comp, sub))
           in
           let intch = intch n in
           let socomp = (Tm.develop suspopcomp, Tm.ty suspopcomp) in
diff --git a/lib/meta_operations/construct.ml b/lib/meta_operations/construct.ml
index db7beb7f..f29c2acf 100644
--- a/lib/meta_operations/construct.ml
+++ b/lib/meta_operations/construct.ml
@@ -8,6 +8,8 @@ module Make (Theory : Theory.S) = struct
   module Opposite = Opposite.Make (Theory)
   module Inverse = Inverse.Make (Theory)
 
+  let mod_coh = assert false
+  let mod_tm = assert false
   let to_tm (tm, _) = tm
   let to_ty (_, ty) = ty
   let characteristic_sub_ps (tm, ty) = (tm, true) :: Unchecked.ty_to_sub_ps ty
@@ -44,19 +46,21 @@ module Make (Theory : Theory.S) = struct
     in
     let ps, ty, _ = Coh.forget coh in
     let sub = elaborate ps tms in
-    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+    (* TODO *)
+    let mod_coh = assert false in
+    (Coh (mod_coh, coh, sub), Unchecked.ty_apply_sub_ps ty sub)
 
   let of_coh coh =
     let ps, ty, _ = Coh.forget coh in
     let id = Unchecked.identity_ps ps in
-    (Coh (coh, id), ty)
+    (Coh (mod_coh, coh, id), ty)
 
   let make_sub ctx list =
     List.map2 (fun (x, (_, b)) t -> (x, (fst t, b))) ctx list
 
   let tm_app_sub tm sub =
     let ty = Tm.ty tm in
-    (App (tm, sub), Unchecked.ty_apply_sub ty sub)
+    (App (mod_tm, tm, sub), Unchecked.ty_apply_sub ty sub)
 
   let of_tm tm =
     let c = Tm.ctx tm in
@@ -101,7 +105,7 @@ module Make (Theory : Theory.S) = struct
     let whisk = whisk3 n j k l in
     let whisk_sub_ps = whisk3_sub_ps k f fty g gty l h hty in
     let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-    ( App (whisk, whisk_sub),
+    ( App (mod_tm, whisk, whisk_sub),
       Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
 
   let intch_comp_nm a b c =
@@ -119,7 +123,7 @@ module Make (Theory : Theory.S) = struct
     let coh = Builtin.intch_comp_nm_coh n m in
     let sub = sub_right @ sub_left in
     let _, ty, _ = Coh.forget coh in
-    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+    (Coh (mod_coh, coh, sub), Unchecked.ty_apply_sub_ps ty sub)
 
   let intch_comp_mn a b c =
     let m = Unchecked.dim_ty (snd a) in
@@ -135,14 +139,17 @@ module Make (Theory : Theory.S) = struct
     let coh = Opposite.coh coh [ 1 ] in
     let sub = sub_right @ sub_left in
     let _, ty, _ = Coh.forget coh in
-    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+    (Coh (mod_coh, coh, sub), Unchecked.ty_apply_sub_ps ty sub)
 
   let opposite (t, ty) op_data = (Opposite.tm t op_data, Opposite.ty ty op_data)
   let inv (t, ty) = (Inverse.compute_inverse t, Inverse.ty ty)
 
   let id constr =
     let d = dim constr in
-    ( Coh (Suspension.coh (Some d) (Builtin.id ()), characteristic_sub_ps constr),
+    ( Coh
+        ( mod_coh,
+          Suspension.coh (Some d) (Builtin.id ()),
+          characteristic_sub_ps constr ),
       arr constr constr )
 
   let rec id_n n constr =
@@ -180,7 +187,9 @@ module Make (Theory : Theory.S) = struct
     let c = first constrs in
     let d = dim c in
     ( Coh
-        (Suspension.coh (Some (d - 1)) (Builtin.comp_n l), glue_subs constrs_rev),
+        ( mod_tm,
+          Suspension.coh (Some (d - 1)) (Builtin.comp_n l),
+          glue_subs constrs_rev ),
       arr (src 1 c) (tgt 1 (first constrs_rev)) )
 
   let comp c1 c2 = comp_n [ c1; c2 ]
@@ -229,7 +238,7 @@ module Make (Theory : Theory.S) = struct
       glue_subs_along k (List.map characteristic_sub_ps constrs)
     in
     let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-    ( App (whisk, whisk_sub),
+    ( App (mod_tm, whisk, whisk_sub),
       Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
 
   let witness constr =
diff --git a/lib/meta_operations/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
index 70b4ca9b..3673a080 100644
--- a/lib/meta_operations/cubical_composite.ml
+++ b/lib/meta_operations/cubical_composite.ml
@@ -7,6 +7,8 @@ module Make (Theory : Theory.S) = struct
   module Suspension = Suspension.Make (Theory)
   module Ps_reduction = Ps_reduction.Make (Theory)
 
+  let mod_coh = assert false
+
   module LinearComp = struct
     module Memo = struct
       let tbl = Hashtbl.create 24
@@ -38,7 +40,8 @@ module Make (Theory : Theory.S) = struct
     let bcomp x y f z g =
       let comp = Builtin.comp_n 2 in
       let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
-      Coh (comp, sub)
+      let mod_coh = assert false in
+      Coh (mod_coh, comp, sub)
 
     let idx_src i = if i = 2 then 0 else i - 3
     let plus i l = if List.mem (Var.Db i) l then tpl i else tdb i
@@ -68,12 +71,14 @@ module Make (Theory : Theory.S) = struct
         in
         sub (2 * arity)
       in
-      let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
+      let mod_coh = assert false in
+      let lin_comp = Coh (mod_coh, Builtin.comp_n arity, lin_incl) in
       bcomp (tdb 0) (tdb 1) (tdb 2) (tdb ((2 * arity) + 1)) lin_comp
 
     let comp_biased_end arity =
       let lin_incl = Unchecked.identity_ps (Builtin.ps_comp arity) in
-      let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
+      let mod_coh = assert false in
+      let lin_comp = Coh (mod_coh, Builtin.comp_n arity, lin_incl) in
       bcomp (tdb 0)
         (tdb ((2 * arity) - 1))
         lin_comp
@@ -100,7 +105,8 @@ module Make (Theory : Theory.S) = struct
             (tdb (k + 2), true) :: (tdb (k + 1), false) :: sub (k - 2)
         | _ -> assert false
       in
-      Coh (comp, sub (2 * arity))
+      let mod_coh = assert false in
+      Coh (mod_coh, comp, sub (2 * arity))
 
     let comp_biased arity pos =
       match pos with
@@ -153,7 +159,8 @@ module Make (Theory : Theory.S) = struct
       let assc = Coh.check_inv ps src tgt ("builtin_assc", 0, []) in
       let sub = sub_assc_i i arity l in
       let _, ty, _ = Coh.forget assc in
-      (Coh (assc, sub), Unchecked.ty_apply_sub_ps ty sub)
+      let mod_coh = assert false in
+      (Coh (mod_coh, assc, sub), Unchecked.ty_apply_sub_ps ty sub)
 
     let whsk i arity l =
       let src = src_i_f i (List.mem (Var.Db (i - 1)) l) in
@@ -162,7 +169,8 @@ module Make (Theory : Theory.S) = struct
       let comp = Builtin.comp_n arity in
       let whsk = F.coh_depth0 comp [ Db i ] in
       let _, ty, _ = Coh.forget whsk in
-      (Coh (whsk, sub), Unchecked.ty_apply_sub_ps ty sub)
+      let mod_coh = assert false in
+      (Coh (mod_coh, whsk, sub), Unchecked.ty_apply_sub_ps ty sub)
 
     let move_at v l arity =
       let mv, ty =
@@ -204,7 +212,8 @@ module Make (Theory : Theory.S) = struct
       let ctx_comp = Unchecked.ps_to_ctx (Builtin.ps_comp arity) in
       let s = sub ctx_comp ~add_src:true base in
       let _, ty, _ = Coh.forget comp in
-      (Coh (comp, s), Unchecked.ty_apply_sub_ps ty s)
+      let mod_coh = assert false in
+      (Coh (mod_coh, comp, s), Unchecked.ty_apply_sub_ps ty s)
 
     let build_cubical arity list =
       match arity with
@@ -247,7 +256,8 @@ module Make (Theory : Theory.S) = struct
 
   (* Construct source (t[i1]) * (tgt_f[i2]) *)
   let naturality_src coh ty tgt ty_base dim l i1 i2 names =
-    let t = Coh (coh, i1) in
+    let mod_coh = assert false in
+    let t = Coh (mod_coh, coh, i1) in
     if l = [] then t
     else
       let tgt_f_ty = Unchecked.rename_ty (F.ty ty_base l tgt) names in
@@ -257,11 +267,12 @@ module Make (Theory : Theory.S) = struct
       let ty = Unchecked.ty_apply_sub_ps ty i1 in
       let coh_src_sub_ps = F.whisk_sub_ps 0 t ty tgt_f tgt_f_ty in
       let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
-      Coh (comp, coh_src_sub_ps)
+      Coh (mod_coh, comp, coh_src_sub_ps)
 
   (* Construct target (src_f[i1]) * (t[i2]) *)
   let naturality_tgt coh ty src ty_base dim l i1 i2 names =
-    let t = Coh (coh, i2) in
+    let mod_coh = assert false in
+    let t = Coh (mod_coh, coh, i2) in
     if l = [] then t
     else
       let src_f_ty = Unchecked.rename_ty (F.ty ty_base l src) names in
@@ -271,7 +282,7 @@ module Make (Theory : Theory.S) = struct
       let ty = Unchecked.ty_apply_sub_ps ty i2 in
       let coh_tgt_sub_ps = F.whisk_sub_ps 0 src_f src_f_ty t ty in
       let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
-      Coh (comp, coh_tgt_sub_ps)
+      Coh (mod_coh, comp, coh_tgt_sub_ps)
 
   let biasor_sub_intch_src ps bdry_f i1 i2 d =
     let ps_red = Ps_reduction.reduce (d - 1) ps in
@@ -303,12 +314,14 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let d = Unchecked.dim_ps gamma in
     let src_ctx, src_incl, i1, i2, bdry_f, l_tgt, names = ctx_src gamma l in
     let coh_src = naturality_src coh coh_ty tgt ty_base d l_tgt i1 i2 names in
-    let coh_tgt = Coh (coh_bridge, biasor_sub_intch_src gamma bdry_f i1 i2 d) in
+    let coh_tgt =
+      Coh (mod_coh, coh_bridge, biasor_sub_intch_src gamma bdry_f i1 i2 d)
+    in
     let intch_coh =
       Coh.check_inv src_ctx coh_src coh_tgt ("intch_src", 0, [])
     in
     let _, ty, _ = Coh.forget intch_coh in
-    let intch = Coh (intch_coh, src_incl) in
+    let intch = Coh (mod_coh, intch_coh, src_incl) in
     let ty = Unchecked.ty_apply_sub_ps ty src_incl in
     (intch, ty)
 
@@ -318,12 +331,14 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let d = Unchecked.dim_ps gamma in
     let tgt_ctx, tgt_incl, i1, i2, bdry_f, l_src, names = ctx_tgt gamma l in
     let coh_tgt = naturality_tgt coh coh_ty src ty_base d l_src i1 i2 names in
-    let coh_src = Coh (coh_bridge, biasor_sub_intch_tgt gamma bdry_f i1 i2 d) in
+    let coh_src =
+      Coh (mod_coh, coh_bridge, biasor_sub_intch_tgt gamma bdry_f i1 i2 d)
+    in
     let intch_coh =
       Coh.check_inv tgt_ctx coh_src coh_tgt ("intch_tgt", 0, [])
     in
     let _, ty, _ = Coh.forget intch_coh in
-    let intch = Coh (intch_coh, tgt_incl) in
+    let intch = Coh (mod_coh, intch_coh, tgt_incl) in
     let ty = Unchecked.ty_apply_sub_ps ty tgt_incl in
     (intch, ty)
 
@@ -339,7 +354,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
       | (t, true) :: (w, false) :: red ->
           let ps_comp, s =
             match t with
-            | Coh (comp, s) ->
+            | Coh (_, comp, s) ->
                 let ps_comp, _, _ = Coh.forget comp in
                 (ps_comp, s)
             | Var v ->
@@ -415,7 +430,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let bridge = depth1_bridge_sub ps_inter l_inter d in
     let bridge = Unchecked.sub_ps_apply_sub bridge (F.sub names l_inter) in
     let coh_bridge_f = F.coh_depth0 coh_bridge l_bridge in
-    let middle = Coh (coh_bridge_f, bridge) in
+    let middle = Coh (mod_coh, coh_bridge_f, bridge) in
     let inner_tgt, final_tgt =
       match intch_tgt_ty with Arr (_, t, t') -> (t, t') | _ -> assert false
     in
@@ -433,7 +448,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let comp = Suspension.coh (Some d) (Builtin.comp_n 3) in
     let ctx = F.ctx (Unchecked.ps_to_ctx ps) l in
     let name = F.pp_data l pp_data in
-    check_term (Ctx.check ctx) ~name (Coh (comp, comp_sub_ps))
+    check_term (Ctx.check ctx) ~name (Coh (mod_coh, comp, comp_sub_ps))
 
   let init () = F.coh_depth1 := coh_depth1
 end
diff --git a/lib/meta_operations/cylinders.ml b/lib/meta_operations/cylinders.ml
index 7dcc132b..b9c5bc10 100644
--- a/lib/meta_operations/cylinders.ml
+++ b/lib/meta_operations/cylinders.ml
@@ -8,6 +8,7 @@ module Make (Theory : Theory.S) = struct
   module Suspension = Suspension.Make (Theory)
   module Builtin = Builtin.Make (Theory)
 
+  let mod_tm = assert false
   let wcomp = Construct.wcomp
 
   (* Cylinder contexts *)
@@ -273,7 +274,7 @@ module Make (Theory : Theory.S) = struct
       in
       let c = Tm.ctx cubcomp in
       let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
-      let tm = App (cubcomp, sub) in
+      let tm = App (mod_tm, cubcomp, sub) in
       check_term (Ctx.check (ctx 2)) ~name:("cylcomp(2,1,2)", 0, []) tm
 
     let intch n =
@@ -336,7 +337,7 @@ module Make (Theory : Theory.S) = struct
                 (Suspension.sub (Some 1) (Cylinder.bdry_left (n - 1) (n - 2)))
             in
             check_term (Ctx.check ctx_comp) ~name:(name, 0, [])
-              (App (comp, sub))
+              (App (mod_tm, comp, sub))
           in
           let intch_lower, intch_upper = intch n in
           let scomp = (Tm.develop suspcomp, Tm.ty suspcomp) in
@@ -636,7 +637,7 @@ module Make (Theory : Theory.S) = struct
             let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
             check_term (Ctx.check ctx)
               ~name:("builtin_cylstack", 0, [])
-              (App (tm, sub))
+              (App (mod_tm, tm, sub))
         | n ->
             let _, upper_incl = ctx (n - 1) in
             let lb = Cylinder.base_lower (n - 1) in
diff --git a/lib/meta_operations/eh.ml b/lib/meta_operations/eh.ml
index 2167ceb9..ce02d093 100644
--- a/lib/meta_operations/eh.ml
+++ b/lib/meta_operations/eh.ml
@@ -11,6 +11,8 @@ module Make (Theory : Theory.S) = struct
   module Functorialisation = Functorialisation.Make (Theory)
   module Inverse = Inverse.Make (Theory)
 
+  let mod_coh = assert false
+
   module type EHArgsS = sig
     val n : int
     val k : int
@@ -486,7 +488,7 @@ module Make (Theory : Theory.S) = struct
       let runit = check_coh (Unchecked.disc 1) cohty ("_ehnat_step1", 0, []) in
       let d = Construct.dim constr in
       let sub = Construct.characteristic_sub_ps constr in
-      ( Coh (Suspension.coh (Some (d - 1)) runit, sub),
+      ( Coh (mod_coh, Suspension.coh (Some (d - 1)) runit, sub),
         Unchecked.ty_apply_sub_ps (Suspension.ty (Some (d - 1)) cohty) sub )
 
     let nat_factor eh_id_id ehargs =
diff --git a/lib/meta_operations/functorialisation.ml b/lib/meta_operations/functorialisation.ml
index 32df22a3..59d1ab99 100644
--- a/lib/meta_operations/functorialisation.ml
+++ b/lib/meta_operations/functorialisation.ml
@@ -9,6 +9,9 @@ module Make (Theory : Theory.S) = struct
   exception NotClosed
   exception Unsupported
 
+  let mod_tm = assert false
+  let mod_coh = assert false
+
   let coh_depth1 =
     ref (fun _ -> Error.fatal "Uninitialised forward reference coh_depth1")
 
@@ -152,7 +155,7 @@ module Make (Theory : Theory.S) = struct
     let whisk = whisk n j k in
     let whisk_sub_ps = whisk_sub_ps k f fty g gty in
     let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-    ( App (whisk, whisk_sub),
+    ( App (mod_tm, whisk, whisk_sub),
       Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
 
   (* Invariant maintained:
@@ -205,7 +208,7 @@ module Make (Theory : Theory.S) = struct
     let ps, _, _ = Coh.forget coh in
     Coh.apply
       (fun c -> ctx c l)
-      (fun t -> ty t l (Coh (coh, Unchecked.identity_ps ps)))
+      (fun t -> ty t l (Coh (mod_coh, coh, Unchecked.identity_ps ps)))
       (fun pp -> pp_data l pp)
       coh
 
@@ -226,7 +229,10 @@ module Make (Theory : Theory.S) = struct
     if l = [] then
       let ps, _, name = Coh.forget c in
       let id = Unchecked.identity_ps ps in
-      check_term (Ctx.check (Unchecked.ps_to_ctx ps)) ~name (Coh (c, id))
+      check_term
+        (Ctx.check (Unchecked.ps_to_ctx ps))
+        ~name
+        (Coh (mod_coh, c, id))
     else
       let cohf, names = coh c l in
       let next =
@@ -245,7 +251,7 @@ module Make (Theory : Theory.S) = struct
         [
           (Var (Var.Bridge v), expl); (Var (Var.Plus v), false); (Var v, false);
         ]
-    | Coh (c, s) ->
+    | Coh (_, c, s) ->
         let t' = Unchecked.tm_rename t (tgt_renaming l) in
         let sf = sub_ps s l in
         let ps, _, _ = Coh.forget c in
@@ -253,9 +259,9 @@ module Make (Theory : Theory.S) = struct
         let places = preimage psc s l in
         let cohf, _ = coh c places in
         let subf = Unchecked.list_to_sub (List.map fst sf) (Tm.ctx cohf) in
-        let tm = App (cohf, subf) in
+        let tm = App (mod_tm, cohf, subf) in
         [ (tm, expl); (t', false); (t, false) ]
-    | App (t, s) ->
+    | App (_, t, s) ->
         let total_t = Unchecked.tm_apply_sub (Tm.develop t) s in
         tm_one_step total_t l expl
     | Meta_tm _ -> raise FunctorialiseMeta
diff --git a/lib/meta_operations/inverse.ml b/lib/meta_operations/inverse.ml
index ef702a25..18aac0e3 100644
--- a/lib/meta_operations/inverse.ml
+++ b/lib/meta_operations/inverse.ml
@@ -30,8 +30,8 @@ module Make (Theory : Theory.S) = struct
     match t with
     | Var x -> raise (NotInvertible (Var.to_string x))
     | Meta_tm _ -> t
-    | Coh (c, sub) -> (
-        try Coh (coh c, sub)
+    | Coh (mod_coh, c, sub) -> (
+        try Coh (mod_coh, coh c, sub)
         with CohNonInv ->
           let ps, _, _ = Coh.forget c in
           let d = Unchecked.dim_ps ps in
@@ -40,8 +40,8 @@ module Make (Theory : Theory.S) = struct
           let sub_inv = sub_inv sub pctx d in
           let equiv = Opposite.equiv_op_ps ps [ d ] in
           let coh = Opposite.coh c [ d ] in
-          Coh (coh, Unchecked.sub_ps_apply_sub equiv sub_inv))
-    | App (t, s) ->
+          Coh (mod_coh, coh, Unchecked.sub_ps_apply_sub equiv sub_inv))
+    | App (_, t, s) ->
         let t = Tm.develop t in
         let total_t = Unchecked.tm_apply_sub t s in
         compute_inverse total_t
@@ -67,7 +67,8 @@ module Make (Theory : Theory.S) = struct
     in
     let coh_vertically_grouped = Ps_reduction.coh coh_unbiased in
     let reduce = Ps_reduction.reduction_sub ps in
-    let t_vertically_grouped = Coh (coh_vertically_grouped, reduce) in
+    let mod_coh = assert false in
+    let t_vertically_grouped = Coh (mod_coh, coh_vertically_grouped, reduce) in
     Coh.check_inv ps t t_vertically_grouped ("vertical_grouping", 0, [])
 
   type lin_comp = { arity : int; dim : int; sub_ps : sub_ps }
@@ -75,7 +76,7 @@ module Make (Theory : Theory.S) = struct
   let tm_to_lin_comp t =
     let ps, sub_ps =
       match t with
-      | Coh (c, s) ->
+      | Coh (_, c, s) ->
           let ps, _, _ = Coh.forget c in
           (ps, s)
       | _ -> Error.fatal "term must be a linear composite"
@@ -108,11 +109,14 @@ module Make (Theory : Theory.S) = struct
         (sub_to_telescope (2 * k) lc.sub_ps [])
         (Suspension.ctx (Some (lc.dim - 1)) ctel)
     in
-    App (Suspension.checked_tm (Some (lc.dim - 1)) tel, stel)
+    let mod_tm = assert false in
+    App (mod_tm, Suspension.checked_tm (Some (lc.dim - 1)) tel, stel)
 
   and cancel_all_linear_comp t =
-    let c, sub =
-      match t with Coh (c, sub) -> (c, sub) | _ -> Error.fatal ""
+    let mod_coh, c, sub =
+      match t with
+      | Coh (mod_coh, c, sub) -> (mod_coh, c, sub)
+      | _ -> Error.fatal ""
     in
     let ps, _, _ = Coh.forget c in
     let d = Unchecked.dim_ps ps in
@@ -126,7 +130,7 @@ module Make (Theory : Theory.S) = struct
             let id =
               Suspension.coh (Some (Unchecked.dim_ty ty_base)) (Builtin.id ())
             in
-            Coh (id, (src_t, true) :: sub_base)
+            Coh (mod_coh, id, (src_t, true) :: sub_base)
           in
           (t_wit, true) :: (id_src_t, false) :: (t, false) :: (src_t, false)
           :: (src_t, false) :: sub
@@ -149,14 +153,14 @@ module Make (Theory : Theory.S) = struct
           in
           Unchecked.wedge_sub_ps_bp lsubs
     in
-    Coh (Functorialisation.coh_all_depth0 c, compute_sub 0 ps sub Obj)
+    Coh (mod_coh, Functorialisation.coh_all_depth0 c, compute_sub 0 ps sub Obj)
 
   and compute_witness t =
     match t with
     | Var x -> raise (NotInvertible (Var.to_string x))
     | Meta_tm _ ->
         raise (NotInvertible "Meta_variable not allowed in witness generation")
-    | Coh (c, s) ->
+    | Coh (_, c, s) ->
         let ps, ty, pp_data = Coh.forget c in
         let d = Coh.dim c in
         let sub_base, u, v =
@@ -167,45 +171,48 @@ module Make (Theory : Theory.S) = struct
         if Coh.is_inv c then
           compute_witness_coh_inv c s ~ps ~d ~pp_data ~sub_base ~u ~v
         else compute_witness_comp c s ~ps ~d ~sub_base ~u ~v
-    | App (t, s) ->
+    | App (_, t, s) ->
         let t = Tm.develop t in
         let total_t = Unchecked.tm_apply_sub t s in
         compute_witness total_t
 
   and compute_witness_coh_inv c s ~ps ~pp_data ~d ~sub_base ~u ~v =
     let name, susp, func = pp_data in
+    let mod_coh = assert false in
     let src_wit =
       let id_ps = Unchecked.identity_ps ps in
       let c_inv = coh c in
       let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
       let c_c_inv =
-        (Coh (c_inv, id_ps), true)
+        (Coh (mod_coh, c_inv, id_ps), true)
         :: (u, false)
-        :: (Coh (c, id_ps), true)
+        :: (Coh (mod_coh, c, id_ps), true)
         :: (v, true) :: (u, true) :: sub_base
       in
-      Coh (comp, c_c_inv)
+      Coh (mod_coh, comp, c_c_inv)
     in
     let tgt_wit =
       let id = Suspension.coh (Some (d - 1)) (Builtin.id ()) in
       let sub_id_u = (u, true) :: sub_base in
-      Coh (id, sub_id_u)
+      Coh (mod_coh, id, sub_id_u)
     in
     let c_wit = Coh.check_inv ps src_wit tgt_wit (name ^ "_Unit", susp, func) in
-    Coh (c_wit, s)
+    Coh (mod_coh, c_wit, s)
 
   and compute_witness_comp c s ~ps ~d ~sub_base ~u ~v =
+    let mod_coh = assert false in
     let ps_doubled, inl, inr = Unchecked.ps_compose (d - 1) ps ps in
     let t =
-      let tm1 = Coh (c, inl) in
+      let tm1 = Coh (mod_coh, c, inl) in
       let c_op = Opposite.coh c [ d ] in
-      let tm2 = Coh (c_op, inr) in
+      let tm2 = Coh (mod_coh, c_op, inr) in
       let sub_inr = Unchecked.sub_ps_to_sub inr in
       let sub_inl = Unchecked.sub_ps_to_sub inl in
       let w = Unchecked.tm_apply_sub (Coh.tgt c_op) sub_inr in
       let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
       Coh
-        ( comp,
+        ( mod_coh,
+          comp,
           (tm2, true) :: (w, false) :: (tm1, true)
           :: Unchecked.sub_ps_apply_sub
                ((v, false) :: (u, false) :: sub_base)
@@ -227,7 +234,7 @@ module Make (Theory : Theory.S) = struct
       in
       let ssinv = Unchecked.pullback_up (d - 1) ps ps s sinv in
       let subsinv = Unchecked.sub_ps_to_sub ssinv in
-      ( Coh (coh, ssinv),
+      ( Coh (mod_coh, coh, ssinv),
         Unchecked.tm_apply_sub src subsinv,
         Unchecked.tm_apply_sub tgt subsinv )
     in
@@ -237,7 +244,7 @@ module Make (Theory : Theory.S) = struct
       let src, tgt = (Coh.src coh, Coh.tgt coh) in
       let s = Unchecked.sub_ps_apply_sub (Unchecked.ps_src ps) sub in
       let sub = Unchecked.sub_ps_to_sub s in
-      ( Coh (coh, s),
+      ( Coh (mod_coh, coh, s),
         Unchecked.tm_apply_sub src sub,
         Unchecked.tm_apply_sub tgt sub )
     in
@@ -246,7 +253,7 @@ module Make (Theory : Theory.S) = struct
       :: (m1, true) :: (tgt_m1, false) :: (src_m1, false)
       :: Unchecked.sub_ps_apply_sub ((u, false) :: (u, false) :: sub_base) sub
     in
-    Coh (Suspension.coh (Some d) (Builtin.comp_n 3), sub_total)
+    Coh (mod_coh, Suspension.coh (Some d) (Builtin.comp_n 3), sub_total)
 
   let compute_witness t =
     try
diff --git a/lib/meta_operations/opposite.ml b/lib/meta_operations/opposite.ml
index e9c6cd0c..21e2e10e 100644
--- a/lib/meta_operations/opposite.ml
+++ b/lib/meta_operations/opposite.ml
@@ -5,20 +5,84 @@ let rec op_data_to_string = function
   | [ i ] -> Printf.sprintf "%i" i
   | i :: l -> Printf.sprintf "%i,%s" i (op_data_to_string l)
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
+let ps ps op_data =
+  let rec level i ps =
+    match ps with
+    | Br [] -> Br []
+    | Br l when List.mem (i + 1) op_data ->
+        let l = List.map (level (i + 1)) l in
+        Br (List.rev l)
+    | Br l -> Br (List.map (level (i + 1)) l)
+  in
+  level 0 ps
 
-  let ps ps op_data =
-    let rec level i ps =
-      match ps with
-      | Br [] -> Br []
-      | Br l when List.mem (i + 1) op_data ->
-          let l = List.map (level (i + 1)) l in
-          Br (List.rev l)
-      | Br l -> Br (List.map (level (i + 1)) l)
-    in
-    level 0 ps
+let op_pp_data pp_data op_data =
+  let name = Printing.full_name pp_data in
+  let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
+  (name, 0, [])
+
+let rec ty typ op_data =
+  let d = Unchecked.dim_ty typ in
+  match typ with
+  | Obj -> Obj
+  | Arr (a, t, u) ->
+      let a = ty a op_data in
+      let t = tm t op_data in
+      let u = tm u op_data in
+      if List.mem d op_data then Arr (a, u, t) else Arr (a, t, u)
+  | Meta_ty m -> Meta_ty m
+
+and tm t op_data =
+  match t with
+  | Var x -> Var x
+  | Coh (mod_coh, c, s) ->
+      let p, _, _ = Coh.forget c in
+      let equiv = equiv_op_ps p op_data in
+      let c = coh c op_data equiv in
+      let op_s = sub (Unchecked.sub_ps_to_sub s) op_data in
+      let s' = Unchecked.sub_ps_apply_sub equiv op_s in
+      Coh (mod_coh, c, s')
+  | App (mod_tm, t, s) ->
+      let op_t, _ =
+        Tm.apply
+          (fun c -> ctx c op_data)
+          (fun t -> tm t op_data)
+          (fun pp_data -> op_pp_data pp_data op_data)
+          t
+      in
+      let op_s = sub s op_data in
+      let op_s = Unchecked.(sub_ps_to_sub (sub_to_sub_ps op_s)) in
+      App (mod_tm, op_t, op_s)
+  | Meta_tm m -> Meta_tm m
+
+and sub s op_data =
+  match s with
+  | [] -> []
+  | (x, (t, e)) :: s -> (x, (tm t op_data, e)) :: sub s op_data
+
+and coh c op_data equiv =
+  Coh.apply_ps
+    (fun p -> ps p op_data)
+    (fun t ->
+      Unchecked.ty_sub_preimage (ty t op_data) (Unchecked.sub_ps_to_sub equiv))
+    (fun pp -> op_pp_data pp op_data)
+    c
+
+and ctx c op_data =
+  match c with
+  | [] -> []
+  | (x, (t, e)) :: c ->
+      let t = ty t op_data in
+      let c = ctx c op_data in
+      (x, (t, e)) :: c
 
+let tm t op_data =
+  Io.info ~v:3 (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
+  let t = tm t op_data in
+  Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
+  t
+
+module Make (K : KernelS) = struct
   let equiv_op_ps ps op_data =
     let rec level i ps =
       match ps with
@@ -31,78 +95,11 @@ module Make (Theory : Theory.S) = struct
     in
     level 0 ps
 
-  let op_pp_data pp_data op_data =
-    let name = Printing.full_name pp_data in
-    let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
-    (name, 0, [])
-
-  let rec ty typ op_data =
-    let d = Unchecked.dim_ty typ in
-    match typ with
-    | Obj -> Obj
-    | Arr (a, t, u) ->
-        let a = ty a op_data in
-        let t = tm t op_data in
-        let u = tm u op_data in
-        if List.mem d op_data then Arr (a, u, t) else Arr (a, t, u)
-    | Meta_ty m -> Meta_ty m
-
-  and tm t op_data =
-    match t with
-    | Var x -> Var x
-    | Coh (c, s) ->
-        let p, _, _ = Coh.forget c in
-        let equiv = equiv_op_ps p op_data in
-        let c = coh c op_data equiv in
-        let op_s = sub (Unchecked.sub_ps_to_sub s) op_data in
-        let s' = Unchecked.sub_ps_apply_sub equiv op_s in
-        Coh (c, s')
-    | App (t, s) ->
-        let op_t, _ =
-          Tm.apply
-            (fun c -> ctx c op_data)
-            (fun t -> tm t op_data)
-            (fun pp_data -> op_pp_data pp_data op_data)
-            t
-        in
-        let op_s = sub s op_data in
-        let op_s = Unchecked.(sub_ps_to_sub (sub_to_sub_ps op_s)) in
-        App (op_t, op_s)
-    | Meta_tm m -> Meta_tm m
-
-  and sub s op_data =
-    match s with
-    | [] -> []
-    | (x, (t, e)) :: s -> (x, (tm t op_data, e)) :: sub s op_data
-
-  and coh c op_data equiv =
-    Coh.apply_ps
-      (fun p -> ps p op_data)
-      (fun t ->
-        Unchecked.ty_sub_preimage (ty t op_data) (Unchecked.sub_ps_to_sub equiv))
-      (fun pp -> op_pp_data pp op_data)
-      c
-
-  and ctx c op_data =
-    match c with
-    | [] -> []
-    | (x, (t, e)) :: c ->
-        let t = ty t op_data in
-        let c = ctx c op_data in
-        (x, (t, e)) :: c
-
   let coh c op_data =
     let ps, _, _ = Coh.forget c in
     let equiv = equiv_op_ps ps op_data in
     coh c op_data equiv
 
-  let tm t op_data =
-    Io.info ~v:3
-      (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
-    let t = tm t op_data in
-    Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
-    t
-
   let checked_tm t op_data =
     let name = Option.map (fun a -> op_pp_data a op_data) (Tm.pp_data t) in
     let c = Tm.ctx t in
diff --git a/lib/meta_operations/opposite.mli b/lib/meta_operations/opposite.mli
index b80053c4..a1db7f1f 100644
--- a/lib/meta_operations/opposite.mli
+++ b/lib/meta_operations/opposite.mli
@@ -1,15 +1,15 @@
 open Common
 
 val op_data_to_string : op_data -> string
+val tm : ('a, 'b) tm -> op_data -> ('a, 'b) tm
+val sub : ('a, 'b) sub -> op_data -> ('a, 'b) sub
+val ty : ('a, 'b) ty -> op_data -> ('a, 'b) ty
+val ctx : ('a, 'b) ctx -> op_data -> ('a, 'b) ctx
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelS) : sig
+  open K
 
-  val equiv_op_ps : ps -> op_data -> sub_ps
-  val tm : tm -> op_data -> tm
   val coh : Coh.t -> op_data -> Coh.t
-  val sub : sub -> op_data -> sub
-  val ty : ty -> op_data -> ty
-  val ctx : ctx -> op_data -> ctx
   val checked_tm : Tm.t -> op_data -> Tm.t
+  val equiv_op_ps : ps -> op_data -> sub_ps
 end
diff --git a/lib/meta_operations/ps_reduction.ml b/lib/meta_operations/ps_reduction.ml
index 329a11c6..a1f0b9aa 100644
--- a/lib/meta_operations/ps_reduction.ml
+++ b/lib/meta_operations/ps_reduction.ml
@@ -13,6 +13,7 @@ module Make (Theory : Theory.S) = struct
     | i, Br l -> Br (List.map (reduce (i - 1)) l)
 
   let reduction_sub ps =
+    let mod_coh = assert false in
     let rec aux i ps =
       match (i, ps) with
       | _, Br [] -> [ (tdb 0, true) ]
@@ -20,7 +21,8 @@ module Make (Theory : Theory.S) = struct
       | 0, Br l ->
           let k = List.length l in
           [
-            (Coh (Builtin.comp_n k, Unchecked.(identity_ps (Br l))), true);
+            ( Coh (mod_coh, Builtin.comp_n k, Unchecked.(identity_ps (Br l))),
+              true );
             (tdb ((2 * k) - 1), false);
             (tdb 0, false);
           ]
diff --git a/lib/meta_operations/telescope.ml b/lib/meta_operations/telescope.ml
index 2cb4cd24..68a68cc9 100644
--- a/lib/meta_operations/telescope.ml
+++ b/lib/meta_operations/telescope.ml
@@ -6,11 +6,15 @@ module Make (Theory : Theory.S) = struct
   module Suspension = Suspension.Make (Theory)
   module Functorialisation = Functorialisation.Make (Theory)
 
+  let mod_coh = assert false
+
   (* returns the associator pairing up the middle two cells of a composite of
     (2*k) 1-cells. The argument is the integer k *)
   let middle_associator k =
     let ps = Builtin.ps_comp (2 * k) in
-    let src = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
+    let src =
+      Coh (mod_coh, Builtin.comp_n (2 * k), Unchecked.(identity_ps ps))
+    in
     let tgt =
       let sub_assoc_middle =
         let rec compute_sub i =
@@ -30,7 +34,7 @@ module Make (Theory : Theory.S) = struct
                   (Var (Db ((2 * k) - 3)), false);
                 ]
               in
-              let comp = Coh (Builtin.comp_n 2, sub_comp) in
+              let comp = Coh (mod_coh, Builtin.comp_n 2, sub_comp) in
               (comp, true)
               :: (Var (Db ((2 * k) + 1)), false)
               :: compute_sub (k - 1)
@@ -41,7 +45,7 @@ module Make (Theory : Theory.S) = struct
         in
         compute_sub ((2 * k) - 1)
       in
-      Coh (Builtin.comp_n ((2 * k) - 1), sub_assoc_middle)
+      Coh (mod_coh, Builtin.comp_n ((2 * k) - 1), sub_assoc_middle)
     in
     Coh.check_inv ps src tgt ("focus", 0, [])
 
@@ -60,7 +64,7 @@ module Make (Theory : Theory.S) = struct
               :: compute_sub (i - 1)
           | i when i = k + 1 ->
               let id =
-                Coh (Builtin.id (), [ (Var (Db ((2 * k) - 1)), false) ])
+                Coh (mod_coh, Builtin.id (), [ (Var (Db ((2 * k) - 1)), false) ])
               in
               (id, true) :: (Var (Db ((2 * k) - 1)), false) :: compute_sub k
           | i ->
@@ -70,9 +74,11 @@ module Make (Theory : Theory.S) = struct
         in
         compute_sub ((2 * k) + 1)
       in
-      Coh (Builtin.comp_n ((2 * k) + 1), sub_id_middle)
+      Coh (mod_coh, Builtin.comp_n ((2 * k) + 1), sub_id_middle)
+    in
+    let tgt =
+      Coh (mod_coh, Builtin.comp_n (2 * k), Unchecked.(identity_ps ps))
     in
-    let tgt = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
     Coh.check_inv ps src tgt ("unit", 0, [])
 
   (* returns the whiskering rewriting the middle term of a composite of (2*k+1)
@@ -94,7 +100,8 @@ module Make (Theory : Theory.S) = struct
     Arr
       ( Arr (Obj, Var (obj (k - 1)), Var (obj (k - 1))),
         Coh
-          ( Builtin.comp_n 2,
+          ( mod_coh,
+            Builtin.comp_n 2,
             [
               (Var (cell_backward k), true);
               (Var (obj (k - 1)), false);
@@ -102,7 +109,7 @@ module Make (Theory : Theory.S) = struct
               (Var (obj k), false);
               (Var (obj (k - 1)), false);
             ] ),
-        Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]) )
+        Coh (mod_coh, Builtin.id (), [ (Var (obj (k - 1)), true) ]) )
 
   let rec ctx k =
     match k with
@@ -126,7 +133,8 @@ module Make (Theory : Theory.S) = struct
         if whisk then
           let src_max_var =
             Coh
-              ( Builtin.comp_n 2,
+              ( mod_coh,
+                Builtin.comp_n 2,
                 [
                   (Var (cell_backward k), true);
                   (Var (obj (k - 1)), false);
@@ -139,7 +147,8 @@ module Make (Theory : Theory.S) = struct
             List.append left
               [
                 (Var (cell_max k), true);
-                (Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]), false);
+                ( Coh (mod_coh, Builtin.id (), [ (Var (obj (k - 1)), true) ]),
+                  false );
                 (src_max_var, false);
                 (Var (obj (k - 1)), false);
               ] )
@@ -163,13 +172,16 @@ module Make (Theory : Theory.S) = struct
           let sub = Unchecked.sub_ps_to_sub sub_ps in
           let t = Unchecked.tm_apply_sub t sub in
           let u = Unchecked.tm_apply_sub u sub in
-          (Coh (coh, sub_ps), t, u)
+          (Coh (mod_coh, coh, sub_ps), t, u)
         in
         let m3, src_m3, tgt_m3 =
           tm_src_tgt (middle_unitor (k - 1)) (sub_ps_telescope_bdry (k - 1))
         in
         let m2 =
-          Coh (middle_rewrite (k - 1), sub_ps_telescope_bdry ~whisk:true k)
+          Coh
+            ( mod_coh,
+              middle_rewrite (k - 1),
+              sub_ps_telescope_bdry ~whisk:true k )
         in
         let m1, src_m1, tgt_m1 =
           tm_src_tgt (middle_associator k) (sub_ps_telescope_bdry k)
@@ -177,7 +189,7 @@ module Make (Theory : Theory.S) = struct
         let sub_telescope =
           [
             (telescope (k - 1), true);
-            (Coh (Builtin.id (), [ (tdb 0, true) ]), false);
+            (Coh (mod_coh, Builtin.id (), [ (tdb 0, true) ]), false);
             (m3, true);
             (tgt_m3, false);
             (m2, true);
@@ -189,7 +201,7 @@ module Make (Theory : Theory.S) = struct
             (tdb 0, false);
           ]
         in
-        Coh (comp, sub_telescope)
+        Coh (mod_coh, comp, sub_telescope)
 
   let checked k =
     let name = "builtin_telescope" ^ string_of_int k in
diff --git a/rocq_plugin/src/export.ml b/rocq_plugin/src/export.ml
index a639113f..3e6167bf 100644
--- a/rocq_plugin/src/export.ml
+++ b/rocq_plugin/src/export.ml
@@ -158,13 +158,13 @@ module Translate (Environment : Environments.S) : TranslateS = struct
   and tm_to_econstr env sigma obj_type eq_type refl ctx tm =
     match tm with
     | Var x -> (env, sigma, EConstr.mkRel (find_db ctx x))
-    | Coh (c, s) ->
+    | Coh (_, c, s) ->
         let env, sigma, c = coh_to_lambda env sigma obj_type eq_type refl c in
         let env, sigma, s =
           sub_ps_to_econstr_array env sigma obj_type eq_type refl ctx s
         in
         (env, sigma, EConstr.mkApp (c, s))
-    | App (tm, s) ->
+    | App (_, tm, s) ->
         let env, sigma, tm = tm_to_lambda env sigma obj_type eq_type refl tm in
         let env, sigma, s =
           sub_to_econstr_array env sigma obj_type eq_type refl ctx s

From e1ab4c78ec7429573c652634f4c652e3a333373a Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Tue, 2 Dec 2025 18:02:35 +0100
Subject: [PATCH 29/30] massive refactor of the kernel

---
 lib/dune                                  |   2 +-
 lib/elaboration/elaborate.ml              |  31 +--
 lib/elaboration/elaborate.mli             |   2 +-
 lib/elaboration/translate_raw.ml          |  13 +-
 lib/elaboration/translate_raw.mli         |   2 +-
 lib/internals/builder.ml                  |   4 +-
 lib/internals/builder.mli                 |   4 +-
 lib/internals/core.mli                    |  14 +-
 lib/internals/fullness.ml                 |   3 +-
 lib/internals/kernel.ml                   |  40 ++-
 lib/internals/kernel.mli                  |   9 +-
 lib/internals/kernelSignature.mli         | 194 +------------
 lib/internals/outerKernel.ml              | 322 ++++++++++++++++++++++
 lib/internals/signature.mli               | 179 ++++++++++++
 lib/internals/theory.ml                   |  22 +-
 lib/internals/theory.mli                  |  12 +-
 lib/lib/command.ml                        |  31 +--
 lib/lib/common.ml                         | 238 +---------------
 lib/lib/common.mli                        | 238 +---------------
 lib/lib/environments.ml                   | 308 ++++++++++-----------
 lib/lib/environments.mli                  |  66 ++---
 lib/lib/kernelExt.mli                     | 133 +++++++++
 lib/lib/meta.mli                          |   4 +-
 lib/lib/raw.ml                            |   2 -
 lib/meta_operations/builtin.ml            |  20 +-
 lib/meta_operations/builtin.mli           |   4 +-
 lib/meta_operations/comp.ml               |   8 +-
 lib/meta_operations/comp.mli              |   4 +-
 lib/meta_operations/cones.ml              |  20 +-
 lib/meta_operations/cones.mli             |   4 +-
 lib/meta_operations/construct.ml          |  43 ++-
 lib/meta_operations/construct.mli         |   4 +-
 lib/meta_operations/cubical_composite.ml  |  63 ++---
 lib/meta_operations/cubical_composite.mli |   2 +-
 lib/meta_operations/cylinders.ml          |  23 +-
 lib/meta_operations/cylinders.mli         |   4 +-
 lib/meta_operations/eh.ml                 |  24 +-
 lib/meta_operations/eh.mli                |   4 +-
 lib/meta_operations/functorialisation.ml  |  26 +-
 lib/meta_operations/functorialisation.mli |   4 +-
 lib/meta_operations/inverse.ml            |  71 +++--
 lib/meta_operations/inverse.mli           |   4 +-
 lib/meta_operations/opposite.ml           | 153 +++++-----
 lib/meta_operations/opposite.mli          |  10 +-
 lib/meta_operations/padding.ml            |  14 +-
 lib/meta_operations/padding.mli           |   4 +-
 lib/meta_operations/ps_reduction.ml       |  10 +-
 lib/meta_operations/ps_reduction.mli      |   4 +-
 lib/meta_operations/suspension.ml         |   4 +-
 lib/meta_operations/suspension.mli        |   4 +-
 lib/meta_operations/telescope.ml          |  50 ++--
 lib/meta_operations/telescope.mli         |   4 +-
 rocq_plugin/src/export.ml                 |  39 ++-
 53 files changed, 1204 insertions(+), 1297 deletions(-)
 create mode 100644 lib/internals/outerKernel.ml
 create mode 100644 lib/internals/signature.mli
 create mode 100644 lib/lib/kernelExt.mli

diff --git a/lib/dune b/lib/dune
index 96e7c69b..18d0f3e9 100644
--- a/lib/dune
+++ b/lib/dune
@@ -3,7 +3,7 @@
 (library
  (name catt)
  (public_name catt)
- (modules_without_implementation raw_types core kernelSignature)
+ (modules_without_implementation raw_types core kernelSignature kernelExt signature)
  (libraries base)
  (instrumentation
   (backend landmarks --auto)))
diff --git a/lib/elaboration/elaborate.ml b/lib/elaboration/elaborate.ml
index 4622bc81..257ca130 100644
--- a/lib/elaboration/elaborate.ml
+++ b/lib/elaboration/elaborate.ml
@@ -9,6 +9,7 @@ module Make (Environment : Environments.S) = struct
   module Translate_raw = Translate_raw.Make (Environment)
   module Raw = Raw.Make (Environment)
   open Environment
+  open K
 
   module Constraints = struct
     type t = { ty : (ty * ty) Queue.t; tm : (tm * tm) Queue.t }
@@ -47,15 +48,15 @@ module Make (Environment : Environments.S) = struct
       | Meta_tm _, Meta_tm _ when tm1 = tm2 -> ()
       | Meta_tm _, _ | _, Meta_tm _ -> Queue.enqueue cst.tm (tm1, tm2)
       | Var v1, Var v2 when v1 = v2 -> ()
-      | Coh (_, coh1, s1), Coh (_, coh2, s2) -> (
+      | Coh (coh1, s1), Coh (coh2, s2) -> (
           try
             Coh.check_equal coh1 coh2;
             unify_sub_ps cst s1 s2
           with Invalid_argument _ ->
             raise (NotUnifiable (Coh.to_string coh1, Coh.to_string coh2)))
-      | App (_, t1, s1), App (_, t2, s2) when t1 == t2 -> unify_sub cst s1 s2
-      | App (_, t, s), ((App _ | Coh _ | Var _) as tm2)
-      | ((Coh _ | Var _) as tm2), App (_, t, s) ->
+      | App (t1, s1), App (t2, s2) when t1 == t2 -> unify_sub cst s1 s2
+      | App (t, s), ((App _ | Coh _ | Var _) as tm2)
+      | ((Coh _ | Var _) as tm2), App (t, s) ->
           unify_tm cst (Unchecked.tm_apply_sub (Tm.develop t) s) tm2
       | Var _, Coh _ | Coh _, Var _ | Var _, Var _ ->
           raise
@@ -99,17 +100,15 @@ module Make (Environment : Environments.S) = struct
       | Meta_tm j when i = j -> tm'
       | Meta_tm _ -> tm
       | Var v -> Var v
-      | Coh (mod_coh, c, s) ->
+      | Coh (c, s) ->
           Coh
-            ( mod_coh,
-              c,
+            ( c,
               List.map
                 (fun (t, expl) -> (tm_replace_meta_tm (i, tm') t, expl))
                 s )
-      | App (mod_tm, t, s) ->
+      | App (t, s) ->
           App
-            ( mod_tm,
-              t,
+            ( t,
               List.map
                 (fun (x, (t, e)) -> (x, (tm_replace_meta_tm (i, tm') t, e)))
                 s )
@@ -216,18 +215,18 @@ module Make (Environment : Environments.S) = struct
               (Printf.sprintf "variable %s not found in context"
                  (Var.to_string v)))
       | Meta_tm i -> (t, List.assoc i meta_ctx)
-      | Coh (mod_coh, c, s) ->
+      | Coh (c, s) ->
           let ps, ty, _ = Coh.forget c in
           let tgt = Unchecked.ps_to_ctx ps in
           let s1 = Unchecked.sub_ps_to_sub s in
           let s1 = sub ctx meta_ctx s1 tgt cst in
-          ( Coh (mod_coh, c, List.map (fun (_, (t, expl)) -> (t, expl)) s1),
+          ( Coh (c, List.map (fun (_, (t, expl)) -> (t, expl)) s1),
             Unchecked.ty_apply_sub ty s1 )
-      | App (mod_tm, t, s) ->
+      | App (t, s) ->
           let tgt = Tm.ctx t in
-          let ty = t.ty.unchecked in
+          let ty = Tm.ty t in
           let s = sub ctx meta_ctx s tgt cst in
-          (App (mod_tm, t, s), Unchecked.ty_apply_sub ty s)
+          (App (t, s), Unchecked.ty_apply_sub ty s)
 
     and sub src meta_ctx s tgt cst =
       Io.info ~v:5
@@ -366,7 +365,7 @@ module Make (Environment : Environments.S) = struct
         let _, names, _ = Unchecked.db_levels ps in
         (PS.mk (Ctx.check ps), Unchecked.rename_ty t names)
       with
-      | PS.Invalid -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
+      | InvalidPS -> raise (Error.invalid_ps (Printing.ctx_to_string ps))
       | DoubledVar x -> raise (Error.doubled_var (Printing.ctx_to_string ps) x)
     with Error.UnknownId s -> raise (Error.unknown_id s)
 end
diff --git a/lib/elaboration/elaborate.mli b/lib/elaboration/elaborate.mli
index acd81e95..5f97599d 100644
--- a/lib/elaboration/elaborate.mli
+++ b/lib/elaboration/elaborate.mli
@@ -2,7 +2,7 @@ open Common
 open Raw_types
 
 module Make (Environment : Environments.S) : sig
-  open Environment
+  open Environment.K
 
   val ctx : (Var.t * tyR) list -> ctx
   val ty : (Var.t * tyR) list -> tyR -> ctx * ty
diff --git a/lib/elaboration/translate_raw.ml b/lib/elaboration/translate_raw.ml
index 17b229a0..527ad0cf 100644
--- a/lib/elaboration/translate_raw.ml
+++ b/lib/elaboration/translate_raw.ml
@@ -6,8 +6,7 @@ exception WrongNumberOfArguments
 module Make (Environment : Environments.S) = struct
   module RawElab = Raw.Make (Environment)
   open Environment
-
-  let mod_tm = assert false
+  open K
 
   let rec head_susp = function
     | VarR _ -> 0
@@ -25,7 +24,7 @@ module Make (Environment : Environments.S) = struct
       let t = Functorialisation.coh_successively coh func in
       let ctx = Tm.ctx t in
       let s, meta_types = sub s ctx expl in
-      (App (mod_tm, t, s), meta_types)
+      (App (t, s), meta_types)
     in
     let make_app tm s susp expl =
       let tm = Suspension.checked_tm susp tm in
@@ -34,21 +33,21 @@ module Make (Environment : Environments.S) = struct
       let t = Functorialisation.tm tm func in
       let ctx = Tm.ctx t in
       let s, meta_types = sub s ctx expl in
-      (App (mod_tm, t, s), meta_types)
+      (App (t, s), meta_types)
     in
     match t with
     | VarR v -> (Var v, [])
     | Sub (VarR v, s, susp, expl) -> (
         match Environment.val_var v with
-        | Coh coh -> make_coh coh s susp expl
-        | Tm t ->
+        | VCoh coh -> make_coh coh s susp expl
+        | VTm t ->
             let t = Suspension.checked_tm susp t in
             let c = Tm.ctx t in
             let func = find_functorialisation s c expl in
             let t = Functorialisation.tm t func in
             let c = Tm.ctx t in
             let s, meta_types = sub s c expl in
-            (App (mod_tm, t, s), meta_types))
+            (App (t, s), meta_types))
     | Sub (BuiltinR b, s, susp, expl) -> (
         match b with
         | Comp ->
diff --git a/lib/elaboration/translate_raw.mli b/lib/elaboration/translate_raw.mli
index f1f4b5ae..07f69123 100644
--- a/lib/elaboration/translate_raw.mli
+++ b/lib/elaboration/translate_raw.mli
@@ -2,7 +2,7 @@ open Common
 open Raw_types
 
 module Make (Environment : Environments.S) : sig
-  open Environment
+  open Environment.K
 
   val tm : tmR -> tm * meta_ctx
   val ty : tyR -> ty * meta_ctx
diff --git a/lib/internals/builder.ml b/lib/internals/builder.ml
index 55e92506..f20510ef 100644
--- a/lib/internals/builder.ml
+++ b/lib/internals/builder.ml
@@ -13,7 +13,7 @@ module Make (Core : Core.S) = struct
 
   (** Operations on substitutions. *)
   module rec Sub :
-    (KernelSignature.SubS
+    (Signature.SubS
       with type checked_tm = Tm.t
        and type checked_coh = Coh.t
        and type checked_ctx = Ctx.t) = struct
@@ -71,7 +71,7 @@ module Make (Core : Core.S) = struct
 
   (** A context, associating a type to each context variable. *)
   and Ctx :
-    (KernelSignature.CtxS
+    (Signature.CtxS
       with type checked_ty = Ty.t
        and type checked_tm = Tm.t
        and type checked_coh = Coh.t
diff --git a/lib/internals/builder.mli b/lib/internals/builder.mli
index 49aaacb2..aac49db6 100644
--- a/lib/internals/builder.mli
+++ b/lib/internals/builder.mli
@@ -9,14 +9,14 @@ module Make : functor (Core : Core.S) -> sig
   open Core
 
   module Ctx :
-    KernelSignature.CtxS
+    Signature.CtxS
       with type checked_ty = Ty.t
        and type checked_tm = Tm.t
        and type checked_coh = Coh.t
        and type checked_ps = PS.t
 
   module Sub :
-    KernelSignature.SubS
+    Signature.SubS
       with type checked_tm = Tm.t
        and type checked_coh = Coh.t
        and type checked_ctx = Ctx.t
diff --git a/lib/internals/core.mli b/lib/internals/core.mli
index 76fb9493..7fff2dbd 100644
--- a/lib/internals/core.mli
+++ b/lib/internals/core.mli
@@ -1,23 +1,19 @@
 open Common
 
 module type S = sig
-  module PS : KernelSignature.PSS
+  module PS : Signature.PSS
 
   module rec Coh :
-    (KernelSignature.CohS
+    (Signature.CohS
       with type innertm = Tm.t
        and type checked_tm = Tm.t
        and type checked_ty = Ty.t)
 
   and Tm :
-    (KernelSignature.TmS
-      with type checked_coh = Coh.t
-       and type checked_ty = Ty.t)
+    (Signature.TmS with type checked_coh = Coh.t and type checked_ty = Ty.t)
 
   and Ty :
-    (KernelSignature.TyS
-      with type checked_tm = Tm.t
-       and type checked_coh = Coh.t)
+    (Signature.TyS with type checked_tm = Tm.t and type checked_coh = Coh.t)
 
   type ty = (Coh.t, Tm.t) pty
   type tm = (Coh.t, Tm.t) ptm
@@ -26,6 +22,6 @@ module type S = sig
   type ctx = (Coh.t, Tm.t) pctx
   type constr = (Coh.t, Tm.t) pconstr
   type meta_ctx = (int * ty) list
-  type value = VCoh of Coh.t | VTm of Tm.t
+  type value = (Coh.t, Tm.t) pvalue
   type decls = (value * string) list
 end
diff --git a/lib/internals/fullness.ml b/lib/internals/fullness.ml
index 9be75995..8c51cc82 100644
--- a/lib/internals/fullness.ml
+++ b/lib/internals/fullness.ml
@@ -1,4 +1,5 @@
 open Std
+open Common
 
 module Make (K : KernelSignature.S) = struct
   open K
@@ -26,7 +27,7 @@ module Make (K : KernelSignature.S) = struct
     List.included (Ctx.domain (Ty.ctx (Tm.checked_ty t))) (tm_free_vars t)
 
   let is_inv_dim t =
-    match Theory.theory.invertibility with
+    match theory.invertibility with
     | None -> false
     | Some d when d >= Ty.dim t -> false
     | _ -> true
diff --git a/lib/internals/kernel.ml b/lib/internals/kernel.ml
index da06df33..b9a86b04 100644
--- a/lib/internals/kernel.ml
+++ b/lib/internals/kernel.ml
@@ -5,9 +5,12 @@ exception IsCoh
 exception IsObj
 exception MetaVariable
 
-module Make (Theory : Theory.S) = struct
+module Make (Theory : sig
+  val theory : theory
+end) =
+struct
   module rec RTy :
-    (KernelSignature.TyS
+    (Signature.TyS
       with type checked_tm = K.Tm.t
        and type checked_coh = K.Coh.t
        and type checked_sub = K.Sub.t
@@ -91,7 +94,7 @@ module Make (Theory : Theory.S) = struct
 
   (** Operations on terms. *)
   and RTm :
-    (KernelSignature.TmS
+    (Signature.TmS
       with type checked_coh = K.Coh.t
        and type checked_sub = K.Sub.t
        and type checked_ty = K.Ty.t
@@ -113,6 +116,7 @@ module Make (Theory : Theory.S) = struct
       name : pp_data option;
     }
 
+    let typ t = t.ty
     let ty t = Ty.forget t.ty
     let checked_ty t = t.ty
     let expr t = t.e
@@ -235,7 +239,7 @@ module Make (Theory : Theory.S) = struct
 
   (** A coherence. *)
   and RCoh :
-    (KernelSignature.CohS
+    (Signature.CohS
       with type innertm = K.Tm.t
        and type checked_ps = K.PS.t
        and type checked_tm = K.Tm.t
@@ -412,9 +416,8 @@ module Make (Theory : Theory.S) = struct
 
   (** Operations on pasting schemes. *)
   and RPS :
-    (KernelSignature.PSS
-      with type inner_ctx = K.Ctx.t
-       and type checked_sub = K.Sub.t) = struct
+    (Signature.PSS with type inner_ctx = K.Ctx.t and type checked_sub = K.Sub.t) =
+  struct
     open K
     open Syntax.Make (Core)
 
@@ -568,7 +571,7 @@ module Make (Theory : Theory.S) = struct
     type ctx = (Coh.t, Tm.t) pctx
     type constr = (Coh.t, Tm.t) pconstr
     type meta_ctx = (int * ty) list
-    type value = VCoh of Coh.t | VTm of Tm.t
+    type value = (Coh.t, Tm.t) pvalue
     type decls = (value * string) list
   end
 
@@ -579,20 +582,20 @@ module Make (Theory : Theory.S) = struct
        and type Tm.t = RTm.t) = struct
     exception InvalidPS
 
-    module Theory = Theory
+    let theory = Theory.theory
 
     module B : sig
       open Core
 
       module Ctx :
-        KernelSignature.CtxS
+        Signature.CtxS
           with type checked_ty = Ty.t
            and type checked_tm = Tm.t
            and type checked_coh = Coh.t
            and type checked_ps = PS.t
 
       module Sub :
-        KernelSignature.SubS
+        Signature.SubS
           with type checked_tm = Tm.t
            and type checked_coh = Coh.t
            and type checked_ctx = Ctx.t
@@ -613,7 +616,7 @@ module Make (Theory : Theory.S) = struct
     type ctx = Core.ctx
     type constr = Core.constr
     type meta_ctx = Core.meta_ctx
-    type value = VCoh of Coh.t | VTm of Tm.t
+    type value = (Coh.t, Tm.t) pvalue
     type decls = (value * string) list
   end
 
@@ -663,3 +666,16 @@ module Make (Theory : Theory.S) = struct
   let check_sub src s tgt =
     ignore @@ Sub.check (Ctx.check src) s (Ctx.check tgt)
 end
+
+let known_kernels : (theory, (module KernelExt.S)) Hashtbl.t = Hashtbl.create 7
+
+let make theory =
+  match Hashtbl.find_opt known_kernels theory with
+  | Some k -> k
+  | None ->
+      let module K = Make (struct
+        let theory = theory
+      end) in
+      let k = (module K : KernelExt.S) in
+      Hashtbl.add known_kernels theory k;
+      k
diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index 26cda6bb..de445772 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,10 +1,3 @@
 open Common
 
-module Make (_ : Theory.S) : sig
-  include KernelS
-
-  val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
-  val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
-  val check_coh : ps -> ty -> pp_data -> Coh.t
-  val check_sub : ctx -> sub -> ctx -> unit
-end
+val make : theory -> (module KernelExt.S)
diff --git a/lib/internals/kernelSignature.mli b/lib/internals/kernelSignature.mli
index 042d74e7..07478698 100644
--- a/lib/internals/kernelSignature.mli
+++ b/lib/internals/kernelSignature.mli
@@ -1,219 +1,43 @@
 open Common
 
-module type TmS = sig
-  type checked_coh
-  type checked_sub
-  type checked_ty
-  type checked_ctx
-
-  type expr =
-    | Var of Var.t
-    | Coh of checked_coh * checked_sub
-    | App of t * checked_sub
-
-  and t
-
-  val ty : t -> (checked_coh, t) pty
-  val checked_ty : t -> checked_ty
-  val forget : t -> (checked_coh, t) ptm
-  val constr : t -> (checked_coh, t) pconstr
-  val ctx : t -> (checked_coh, t) pctx
-  val name : t -> string option
-  val full_name : t -> string option
-  val func_data : t -> (Var.t * int) list list option
-  val of_coh : checked_coh -> t
-  val preimage : t -> checked_sub -> t
-  val develop : t -> (checked_coh, t) ptm
-  val pp_data : t -> pp_data option
-  val to_string : t -> string
-  val is_equal : t -> t -> bool
-  val apply_sub : t -> checked_sub -> t
-  val to_var : t -> Var.t
-  val expr : t -> expr
-
-  val check_in_ctx :
-    checked_ctx -> ?ty:checked_ty -> ?name:pp_data -> (checked_coh, t) ptm -> t
-
-  val check :
-    (checked_coh, t) pctx ->
-    ?ty:(checked_coh, t) pty ->
-    ?name:pp_data ->
-    (checked_coh, t) ptm ->
-    t
-
-  val apply :
-    ((checked_coh, t) pctx -> (checked_coh, t) pctx) ->
-    ((checked_coh, t) ptm -> (checked_coh, t) ptm) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t * (checked_coh, t) psub
-end
-
-module type CohS = sig
-  type t
-  type innertm
-  type checked_ps
-  type checked_tm
-  type checked_ty
-
-  val ps : t -> checked_ps
-  val forget : t -> ps * (t, checked_tm) pty * pp_data
-  val suspend : t -> t
-  val is_equal : t -> t -> bool
-  val check_equal : t -> t -> unit
-  val is_inv : t -> bool
-  val to_string : ?unroll:bool -> t -> string
-  val dim : t -> int
-  val src : t -> (t, checked_tm) ptm
-  val tgt : t -> (t, checked_tm) ptm
-  val check : ps -> (t, checked_tm) pty -> pp_data -> t
-  val ty : t -> checked_ty
-
-  val check_noninv :
-    ps -> (t, checked_tm) ptm -> (t, checked_tm) ptm -> pp_data -> t
-
-  val check_inv :
-    ps -> (t, checked_tm) ptm -> (t, checked_tm) ptm -> pp_data -> t
-
-  val noninv_srctgt :
-    t -> (t, checked_tm) ptm * (t, checked_tm) ptm * (t, checked_tm) pty
-
-  val func_data : t -> (Var.t * int) list list
-
-  val apply_ps :
-    (ps -> ps) ->
-    ((t, checked_tm) pty -> (t, checked_tm) pty) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t
-
-  val apply :
-    ((t, checked_tm) pctx -> (t, checked_tm) pctx) ->
-    ((t, checked_tm) pty -> (t, checked_tm) pty) ->
-    (pp_data -> pp_data) ->
-    t ->
-    t * (t, checked_tm) psub
-end
-
-module type TyS = sig
-  type checked_tm
-  type checked_coh
-  type checked_ctx
-  type checked_sub
-  type t
-  type expr = Obj | Arr of t * checked_tm * checked_tm
-
-  val check : checked_ctx -> (checked_coh, checked_tm) pty -> t
-  val apply_sub : t -> checked_sub -> t
-  val ctx : t -> checked_ctx
-  val check_equal : t -> t -> unit
-  val morphism : checked_tm -> checked_tm -> t
-  val to_string : t -> string
-  val dim : t -> int
-  val is_equal : t -> t -> bool
-  val forget : t -> (checked_coh, checked_tm) pty
-  val expr : t -> expr
-
-  val check_with_ctx :
-    (checked_coh, checked_tm) pctx -> (checked_coh, checked_tm) pty -> t
-end
-
-module type PSS = sig
-  type t = ps
-  type inner_ctx
-  type checked_sub
-
-  val to_string : t -> string
-  val mk : inner_ctx -> t
-  val source : t -> checked_sub
-  val target : t -> checked_sub
-  val bdry : t -> t
-  val is_equal : t -> t -> bool
-end
-
-module type CtxS = sig
-  type checked_ty
-  type checked_coh
-  type checked_tm
-  type checked_ps
-
-  type t = private {
-    c : (Common.Var.t * checked_ty) list;
-    unchecked : (checked_coh, checked_tm) pctx;
-  }
-
-  val check : (checked_coh, checked_tm) pctx -> t
-  val to_string : t -> string
-  val forget : t -> (checked_coh, checked_tm) pctx
-  val is_equal : t -> t -> bool
-  val check_equal : t -> t -> unit
-  val ty_var : t -> Var.t -> checked_ty
-  val domain : t -> Var.t list
-  val of_ps : checked_ps -> t
-  val check_notin : t -> Var.t -> unit
-  val extend : t -> expl:bool -> Var.t -> (checked_coh, checked_tm) pty -> t
-  val empty : unit -> t
-end
-
-module type SubS = sig
-  type checked_tm
-  type checked_ctx
-  type checked_coh
-
-  type t = private {
-    list : checked_tm list;
-    src : checked_ctx;
-    tgt : checked_ctx;
-    unchecked : (checked_coh, checked_tm) psub;
-  }
-
-  val check : checked_ctx -> (checked_coh, checked_tm) psub -> checked_ctx -> t
-
-  val check_to_ps :
-    checked_ctx -> (checked_coh, checked_tm) psub_ps -> Common.ps -> t
-
-  val forget : t -> (checked_coh, checked_tm) psub
-  val src : t -> checked_ctx
-  val tgt : t -> checked_ctx
-end
-
 module type S = sig
   exception InvalidPS
 
-  module Theory : Theory.S
+  val theory : theory
 
   module rec Coh :
-    (CohS
+    (Signature.CohS
       with type innertm = Tm.t
        and type checked_ps = PS.t
        and type checked_tm = Tm.t
        and type checked_ty = Ty.t)
 
   and Ty :
-    (TyS
+    (Signature.TyS
       with type checked_tm = Tm.t
        and type checked_coh = Coh.t
        and type checked_sub = Sub.t
        and type checked_ctx = Ctx.t)
 
   and Tm :
-    (TmS
+    (Signature.TmS
       with type checked_coh = Coh.t
        and type checked_sub = Sub.t
        and type checked_ty = Ty.t
        and type checked_ctx = Ctx.t)
 
-  and PS : (PSS with type inner_ctx = Ctx.t and type checked_sub = Sub.t)
+  and PS :
+    (Signature.PSS with type inner_ctx = Ctx.t and type checked_sub = Sub.t)
 
   and Ctx :
-    (CtxS
+    (Signature.CtxS
       with type checked_ty = Ty.t
        and type checked_coh = Coh.t
        and type checked_tm = Tm.t
        and type checked_ps = PS.t)
 
   and Sub :
-    (SubS
+    (Signature.SubS
       with type checked_tm = Tm.t
        and type checked_coh = Coh.t
        and type checked_ctx = Ctx.t)
@@ -225,6 +49,6 @@ module type S = sig
   type ctx = (Coh.t, Tm.t) pctx
   type constr = (Coh.t, Tm.t) pconstr
   type meta_ctx = (int * ty) list
-  type value = VCoh of Coh.t | VTm of Tm.t
+  type value = (Coh.t, Tm.t) pvalue
   type decls = (value * string) list
 end
diff --git a/lib/internals/outerKernel.ml b/lib/internals/outerKernel.ml
new file mode 100644
index 00000000..8cdc1253
--- /dev/null
+++ b/lib/internals/outerKernel.ml
@@ -0,0 +1,322 @@
+(* open Common *)
+(* module CoreSignature = Core *)
+
+(* exception IsCoh *)
+(* exception IsObj *)
+(* exception MetaVariable *)
+
+(* module Make (Theory : Theory.S) = struct *)
+(*   module InnerKernel = Kernel.Make (Theory) *)
+(*   module Coh = InnerKernel.Coh *)
+
+(*   (\** Operations on terms. *\) *)
+(*   module rec Tm : sig *)
+(*     type expr = *)
+(*       [ `Var of Var.t | `Coh of Coh.t * B.Sub.t | `App of Tm.t * B.Sub.t ] *)
+
+(*     and t = private { *)
+(*       ty : B.Ty.t; *)
+(*       e : expr; *)
+(*       unchecked : (Coh.t, t) tm; *)
+(*       mutable developped : (Coh.t, t) tm option; *)
+(*       name : pp_data option; *)
+(*     } *)
+
+(*     (\* Data extraction *\) *)
+(*     val to_var : t -> Var.t *)
+(*     val ty : t -> (Coh.t, Tm.t) ty *)
+(*     val ctx : t -> (Coh.t, Tm.t) ctx *)
+(*     val forget : t -> (Coh.t, Tm.t) tm *)
+(*     val constr : t -> (Coh.t, Tm.t) constr *)
+(*     val name : t -> string option *)
+(*     val full_name : t -> string option *)
+(*     val func_data : t -> (Var.t * int) list list option *)
+(*     val pp_data : t -> pp_data option *)
+(*     val to_string : t -> string *)
+
+(*     (\* Production of terms *\) *)
+(*     val of_coh : Coh.t -> t *)
+
+(*     val check_in_ctx : *)
+(*       B.Ctx.t -> ?ty:B.Ty.t -> ?name:pp_data -> (Coh.t, Tm.t) tm -> t *)
+
+(*     val check : *)
+(*       (Coh.t, Tm.t) ctx -> *)
+(*       ?ty:(Coh.t, Tm.t) ty -> *)
+(*       ?name:pp_data -> *)
+(*       (Coh.t, Tm.t) tm -> *)
+(*       t *)
+
+(*     val apply_sub : t -> B.Sub.t -> t *)
+(*     val preimage : t -> B.Sub.t -> t *)
+(*     val develop : t -> (Coh.t, Tm.t) tm *)
+
+(*     val apply : *)
+(*       ((Coh.t, Tm.t) ctx -> (Coh.t, Tm.t) ctx) -> *)
+(*       ((Coh.t, Tm.t) tm -> (Coh.t, Tm.t) tm) -> *)
+(*       (pp_data -> pp_data) -> *)
+(*       t -> *)
+(*       t * (Coh.t, Tm.t) sub *)
+
+(*     val is_equal : t -> t -> bool *)
+(*   end = struct *)
+(*     open Syntax.Make (Core) *)
+(*     module Ty = B.Ty *)
+(*     module Ctx = B.Ctx *)
+(*     module Sub = B.Sub *)
+
+(*     type expr = *)
+(*       [ `Var of Var.t | `Coh of Coh.t * B.Sub.t | `App of Tm.t * B.Sub.t ] *)
+
+(*     type t = { *)
+(*       ty : Ty.t; *)
+(*       e : expr; *)
+(*       unchecked : tm; *)
+(*       mutable developped : tm option; *)
+(*       name : pp_data option; *)
+(*     } *)
+
+(*     let ty t = t.ty.unchecked *)
+(*     let tbl : (B.Ctx.t * tm, Tm.t) Hashtbl.t = Hashtbl.create 7829 *)
+(*     let forget tm = tm.unchecked *)
+(*     let constr tm = (forget tm, ty tm) *)
+
+(*     let check_in_ctx c ?ty ?name t = *)
+(*       Io.info ~v:5 *)
+(*         (lazy *)
+(*           (Printf.sprintf "building kernel term %s in context %s" *)
+(*              (Printing.tm_to_string t) (Ctx.to_string c))); *)
+(*       let tm = *)
+(*         match Hashtbl.find_opt tbl (c, t) with *)
+(*         | Some tm -> tm *)
+(*         | None -> ( *)
+(*             match t with *)
+(*             | Var x -> *)
+(*                 let e, ty = (`Var x, Ty.check c (Ctx.ty_var c x).unchecked) in *)
+(*                 { ty; e; unchecked = t; developped = Some t; name } *)
+(*             | Meta_tm _ -> raise MetaVariable *)
+(*             | Coh (coh, s) -> *)
+(*                 let sub = Sub.check_to_ps c s (Coh.ps coh) in *)
+(*                 let e, ty = (`Coh (coh, sub), Ty.apply_sub (Coh.ty coh) sub) in *)
+(*                 let tm = { ty; e; unchecked = t; developped = Some t; name } in *)
+(*                 Hashtbl.add tbl (c, t) tm; *)
+(*                 tm *)
+(*             | App (u, s) -> *)
+(*                 let ty = u.ty in *)
+(*                 let sub = Sub.check c s ty.c in *)
+(*                 let e, ty = (`App (u, sub), Ty.apply_sub ty sub) in *)
+(*                 let tm = { ty; e; unchecked = t; developped = None; name } in *)
+(*                 Hashtbl.add tbl (c, t) tm; *)
+(*                 tm) *)
+(*       in *)
+(*       match ty with *)
+(*       | None -> tm *)
+(*       | Some ty -> *)
+(*           Ty.check_equal ty tm.ty; *)
+(*           tm *)
+
+(*     let check c ?ty ?name tm = *)
+(*       let c = Ctx.check c in *)
+(*       let ty = Option.map (Ty.check c) ty in *)
+(*       check_in_ctx c ?ty ?name tm *)
+
+(*     let develop tm = *)
+(*       match tm.developped with *)
+(*       | Some t -> t *)
+(*       | None -> *)
+(*           let dev = *)
+(*             match tm.e with *)
+(*             | `Var _ | `Coh (_, _) -> tm.unchecked *)
+(*             | `App (t, s) -> *)
+(*                 let dt = Tm.develop t in *)
+(*                 let s = s.unchecked in *)
+(*                 Unchecked.tm_apply_sub dt s *)
+(*           in *)
+(*           tm.developped <- Some dev; *)
+(*           dev *)
+
+(*     let to_var tm = *)
+(*       match tm.e with *)
+(*       | `Var v -> v *)
+(*       | `Coh _ -> raise IsCoh *)
+(*       | `App _ -> ( *)
+(*           match develop tm with *)
+(*           | Var v -> v *)
+(*           | Coh _ -> raise IsCoh *)
+(*           | App _ | Meta_tm _ -> assert false) *)
+
+(*     let apply_sub t (sub : B.Sub.t) = *)
+(*       Ctx.check_equal sub.tgt t.ty.c; *)
+(*       let c = sub.src in *)
+(*       let ty = Ty.apply_sub t.ty sub in *)
+(*       let t = Unchecked.tm_apply_sub (forget t) sub.unchecked in *)
+(*       check_in_ctx c ~ty t *)
+
+(*     let preimage t (sub : B.Sub.t) = *)
+(*       Ctx.check_equal sub.src t.ty.c; *)
+(*       let c = sub.tgt in *)
+(*       let t = Unchecked.tm_sub_preimage (forget t) sub.unchecked in *)
+(*       check_in_ctx c t *)
+
+(*     let is_equal t1 t2 = *)
+(*       Ctx.is_equal t1.ty.c t2.ty.c *)
+(*       && Equality.is_equal_tm t1.unchecked t2.unchecked *)
+
+(*     let apply fun_ctx fun_tm fun_pp_data tm = *)
+(*       let c = fun_ctx (Ctx.forget tm.ty.c) in *)
+(*       let db_sub = Unchecked.db_level_sub_inv c in *)
+(*       let c, _, _ = Unchecked.db_levels c in *)
+(*       let c = Ctx.check c in *)
+(*       let newexp = Unchecked.tm_apply_sub (fun_tm (forget tm)) db_sub in *)
+(*       let name = *)
+(*         Option.map *)
+(*           (fun pp_data -> *)
+(*             Display_maps.pp_data_rename (fun_pp_data pp_data) db_sub) *)
+(*           tm.name *)
+(*       in *)
+(*       (check_in_ctx c ?name newexp, db_sub) *)
+
+(*     let ctx t = Ctx.forget t.ty.c *)
+(*     let name t = Option.map Printing.pp_data_to_string t.name *)
+(*     let full_name t = Option.map Printing.full_name t.name *)
+(*     let func_data t = Option.map (fun (_, _, f) -> f) t.name *)
+(*     let pp_data t = t.name *)
+
+(*     let to_string t = *)
+(*       match full_name t with *)
+(*       | Some name -> name *)
+(*       | None -> Printing.tm_to_string (forget t) *)
+
+(*     let of_coh coh = *)
+(*       let ps, _, pp_data = Coh.forget coh in *)
+(*       let id = Unchecked.identity_ps ps in *)
+(*       let ctx = Unchecked.ps_to_ctx ps in *)
+(*       check_in_ctx (Ctx.check ctx) ~name:pp_data (Coh (coh, id)) *)
+(*   end *)
+
+(*   and Ty : sig *)
+(*     type t *)
+(*   end = struct end *)
+
+(*   and Core : *)
+(*     (CoreSignature.S *)
+(*       with type Ty.t = Ty.t *)
+(*       with type Coh.t = Coh.t *)
+(*       with type Coh.innertm = InnerKernel.Tm.t *)
+(*       with type Tm.t = Tm.t) = struct *)
+(*     module PS = PS *)
+(*     module Ty = Ty *)
+(*     module Tm = Tm *)
+(*     module Coh = Coh *)
+(*   end *)
+
+(*   and B : sig *)
+(*     exception IsObj *)
+(*     exception IsCoh *)
+(*     exception InvalidSubTarget of string * string *)
+(*     exception MetaVariable *)
+
+(*     module rec Sub : sig *)
+(*       type t = private { *)
+(*         list : Tm.t list; *)
+(*         src : Ctx.t; *)
+(*         tgt : Ctx.t; *)
+(*         unchecked : (Coh.t, Tm.t) sub; *)
+(*       } *)
+
+(*       val check : Ctx.t -> (Coh.t, Tm.t) sub -> Ctx.t -> t *)
+(*       val check_to_ps : Ctx.t -> (Coh.t, Tm.t) sub_ps -> PS.t -> Sub.t *)
+(*     end *)
+
+(*     and Ctx : sig *)
+(*       type t = private { *)
+(*         c : (Var.t * Ty.t) list; *)
+(*         unchecked : (Coh.t, Tm.t) ctx; *)
+(*       } *)
+
+(*       val to_string : t -> string *)
+(*       val ty_var : t -> Var.t -> Ty.t *)
+(*       val domain : t -> Var.t list *)
+(*       val forget : t -> (Coh.t, Tm.t) ctx *)
+(*       val check : (Coh.t, Tm.t) ctx -> t *)
+(*       val is_equal : t -> t -> bool *)
+(*       val check_equal : t -> t -> unit *)
+(*     end *)
+
+(*     and PS : sig *)
+(*       exception Invalid *)
+
+(*       type t = ps *)
+
+(*       val to_string : t -> string *)
+(*       val mk : Ctx.t -> t *)
+(*       val bdry : t -> t *)
+(*       val source : t -> Sub.t *)
+(*       val target : t -> Sub.t *)
+(*       val is_equal : t -> t -> bool *)
+(*     end *)
+
+(*     and Ty : sig *)
+(*       type t = private { c : Ctx.t; e : expr; unchecked : (Coh.t, Tm.t) ty } *)
+(*       and expr = Obj | Arr of t * Tm.t * Tm.t *)
+
+(*       val to_string : t -> string *)
+(*       val is_equal : t -> t -> bool *)
+(*       val check_equal : t -> t -> unit *)
+(*       val morphism : Tm.t -> Tm.t -> Ty.t *)
+(*       val check : Ctx.t -> (Coh.t, Tm.t) ty -> t *)
+(*       val apply_sub : t -> Sub.t -> t *)
+(*       val dim : t -> int *)
+(*     end *)
+(*   end = *)
+(*     Builder.Make (Core) *)
+
+(*   module Ty = B.Ty *)
+(*   module Ctx = B.Ctx *)
+(*   module Sub = B.Sub *)
+(*   module PS = B.PS *)
+(*   include Syntax.Make (Core) *)
+
+(*   let check check_fn name = *)
+(*     let v = 2 in *)
+(*     let fname = if !Settings.verbosity >= v then Lazy.force name else "" in *)
+(*     Io.info ~v (lazy ("checking " ^ fname)); *)
+(*     try check_fn () with *)
+(*     | NotEqual (s1, s2) -> *)
+(*         Error.untypable *)
+(*           (if !Settings.verbosity >= v then fname else Lazy.force name) *)
+(*           (Printf.sprintf "%s and %s are not equal" s1 s2) *)
+(*     | B.InvalidSubTarget (s, tgt) -> *)
+(*         Error.untypable *)
+(*           (if !Settings.verbosity >= v then fname else Lazy.force name) *)
+(*           (Printf.sprintf "substitution %s does not apply from context %s" s tgt) *)
+(*     | Error.UnknownId s -> *)
+(*         Error.untypable *)
+(*           (if !Settings.verbosity >= v then fname else Lazy.force name) *)
+(*           (Printf.sprintf "unknown identifier :%s" s) *)
+(*     | MetaVariable -> *)
+(*         Error.incomplete_constraints *)
+(*           (if !Settings.verbosity >= v then fname else Lazy.force name) *)
+
+(*   let check_type ctx a = *)
+(*     let ty = lazy ("type: " ^ Printing.ty_to_string a) in *)
+(*     check (fun () -> Ty.check ctx a) ty *)
+
+(*   let check_term ctx ?ty ?name t = *)
+(*     let ty = Option.map (check_type ctx) ty in *)
+(*     let tm = lazy ("term: " ^ Printing.tm_to_string t) in *)
+(*     check (fun () -> Tm.check_in_ctx ctx ?ty ?name t) tm *)
+
+(*   let check_constr ?name ctx constr = *)
+(*     let ctx = Ctx.check ctx in *)
+(*     let t, ty = constr in *)
+(*     let ty = if !Settings.debug then None else Some ty in *)
+(*     check_term ctx ?ty ?name t *)
+
+(*   let check_coh ps ty pp_data = *)
+(*     let c = lazy ("coherence: " ^ Printing.pp_data_to_string pp_data) in *)
+(*     check (fun () -> Coh.check ps ty pp_data) c *)
+
+(*   let check_sub src s tgt = *)
+(*     ignore @@ Sub.check (Ctx.check src) s (Ctx.check tgt) *)
+(* end *)
diff --git a/lib/internals/signature.mli b/lib/internals/signature.mli
new file mode 100644
index 00000000..b7a4d376
--- /dev/null
+++ b/lib/internals/signature.mli
@@ -0,0 +1,179 @@
+open Common
+
+module type TmS = sig
+  type checked_coh
+  type checked_sub
+  type checked_ty
+  type checked_ctx
+
+  type expr =
+    | Var of Var.t
+    | Coh of checked_coh * checked_sub
+    | App of t * checked_sub
+
+  and t
+
+  val typ : t -> checked_ty
+  val ty : t -> (checked_coh, t) pty
+  val checked_ty : t -> checked_ty
+  val forget : t -> (checked_coh, t) ptm
+  val constr : t -> (checked_coh, t) pconstr
+  val ctx : t -> (checked_coh, t) pctx
+  val name : t -> string option
+  val full_name : t -> string option
+  val func_data : t -> (Var.t * int) list list option
+  val of_coh : checked_coh -> t
+  val preimage : t -> checked_sub -> t
+  val develop : t -> (checked_coh, t) ptm
+  val pp_data : t -> pp_data option
+  val to_string : t -> string
+  val is_equal : t -> t -> bool
+  val apply_sub : t -> checked_sub -> t
+  val to_var : t -> Var.t
+  val expr : t -> expr
+
+  val check_in_ctx :
+    checked_ctx -> ?ty:checked_ty -> ?name:pp_data -> (checked_coh, t) ptm -> t
+
+  val check :
+    (checked_coh, t) pctx ->
+    ?ty:(checked_coh, t) pty ->
+    ?name:pp_data ->
+    (checked_coh, t) ptm ->
+    t
+
+  val apply :
+    ((checked_coh, t) pctx -> (checked_coh, t) pctx) ->
+    ((checked_coh, t) ptm -> (checked_coh, t) ptm) ->
+    (pp_data -> pp_data) ->
+    t ->
+    t * (checked_coh, t) psub
+end
+
+module type CohS = sig
+  type t
+  type innertm
+  type checked_ps
+  type checked_tm
+  type checked_ty
+
+  val ps : t -> checked_ps
+  val forget : t -> ps * (t, checked_tm) pty * pp_data
+  val suspend : t -> t
+  val is_equal : t -> t -> bool
+  val check_equal : t -> t -> unit
+  val is_inv : t -> bool
+  val to_string : ?unroll:bool -> t -> string
+  val dim : t -> int
+  val src : t -> (t, checked_tm) ptm
+  val tgt : t -> (t, checked_tm) ptm
+  val check : ps -> (t, checked_tm) pty -> pp_data -> t
+  val ty : t -> checked_ty
+
+  val check_noninv :
+    ps -> (t, checked_tm) ptm -> (t, checked_tm) ptm -> pp_data -> t
+
+  val check_inv :
+    ps -> (t, checked_tm) ptm -> (t, checked_tm) ptm -> pp_data -> t
+
+  val noninv_srctgt :
+    t -> (t, checked_tm) ptm * (t, checked_tm) ptm * (t, checked_tm) pty
+
+  val func_data : t -> (Var.t * int) list list
+
+  val apply_ps :
+    (ps -> ps) ->
+    ((t, checked_tm) pty -> (t, checked_tm) pty) ->
+    (pp_data -> pp_data) ->
+    t ->
+    t
+
+  val apply :
+    ((t, checked_tm) pctx -> (t, checked_tm) pctx) ->
+    ((t, checked_tm) pty -> (t, checked_tm) pty) ->
+    (pp_data -> pp_data) ->
+    t ->
+    t * (t, checked_tm) psub
+end
+
+module type TyS = sig
+  type checked_tm
+  type checked_coh
+  type checked_ctx
+  type checked_sub
+  type t
+  type expr = Obj | Arr of t * checked_tm * checked_tm
+
+  val check : checked_ctx -> (checked_coh, checked_tm) pty -> t
+  val apply_sub : t -> checked_sub -> t
+  val ctx : t -> checked_ctx
+  val check_equal : t -> t -> unit
+  val morphism : checked_tm -> checked_tm -> t
+  val to_string : t -> string
+  val dim : t -> int
+  val is_equal : t -> t -> bool
+  val forget : t -> (checked_coh, checked_tm) pty
+  val expr : t -> expr
+
+  val check_with_ctx :
+    (checked_coh, checked_tm) pctx -> (checked_coh, checked_tm) pty -> t
+end
+
+module type PSS = sig
+  type t = ps
+  type inner_ctx
+  type checked_sub
+
+  val to_string : t -> string
+  val mk : inner_ctx -> t
+  val source : t -> checked_sub
+  val target : t -> checked_sub
+  val bdry : t -> t
+  val is_equal : t -> t -> bool
+end
+
+module type CtxS = sig
+  type checked_ty
+  type checked_coh
+  type checked_tm
+  type checked_ps
+
+  type t = private {
+    c : (Common.Var.t * checked_ty) list;
+    unchecked : (checked_coh, checked_tm) pctx;
+  }
+
+  val check : (checked_coh, checked_tm) pctx -> t
+  val to_string : t -> string
+  val forget : t -> (checked_coh, checked_tm) pctx
+  val is_equal : t -> t -> bool
+  val check_equal : t -> t -> unit
+  val ty_var : t -> Var.t -> checked_ty
+  val domain : t -> Var.t list
+  val of_ps : checked_ps -> t
+  val check_notin : t -> Var.t -> unit
+  val extend : t -> expl:bool -> Var.t -> (checked_coh, checked_tm) pty -> t
+  val empty : unit -> t
+end
+
+module type SubS = sig
+  type checked_tm
+  type checked_ctx
+  type checked_coh
+
+  type t = private {
+    list : checked_tm list;
+    src : checked_ctx;
+    tgt : checked_ctx;
+    unchecked : (checked_coh, checked_tm) psub;
+  }
+
+  val check : checked_ctx -> (checked_coh, checked_tm) psub -> checked_ctx -> t
+
+  val check_to_ps :
+    checked_ctx -> (checked_coh, checked_tm) psub_ps -> Common.ps -> t
+
+  val forget : t -> (checked_coh, checked_tm) psub
+  val src : t -> checked_ctx
+  val tgt : t -> checked_ctx
+end
diff --git a/lib/internals/theory.ml b/lib/internals/theory.ml
index 9e792e04..19b56ab8 100644
--- a/lib/internals/theory.ml
+++ b/lib/internals/theory.ml
@@ -1,13 +1,13 @@
-open Common
+(* open Common *)
 
-module type S = sig
-  val theory : theory
-  val environment_created : bool ref
-end
+(* module type S = sig *)
+(*   val theory : theory *)
+(*   val environment_created : bool ref *)
+(* end *)
 
-let make theory =
-  let module Theory = struct
-    let theory = theory
-    let environment_created = ref false
-  end in
-  (module Theory : S)
+(* let make theory = *)
+(*   let module Theory = struct *)
+(*     let theory = theory *)
+(*     let environment_created = ref false *)
+(*   end in *)
+(*   (module Theory : S) *)
diff --git a/lib/internals/theory.mli b/lib/internals/theory.mli
index 1c551251..b857de1d 100644
--- a/lib/internals/theory.mli
+++ b/lib/internals/theory.mli
@@ -1,8 +1,8 @@
-open Common
+(* open Common *)
 
-module type S = sig
-  val theory : theory
-  val environment_created : bool ref
-end
+(* module type S = sig *)
+(*   val theory : theory *)
+(*   val environment_created : bool ref *)
+(* end *)
 
-val make : theory -> (module S)
+(* val make : theory -> (module S) *)
diff --git a/lib/lib/command.ml b/lib/lib/command.ml
index c5fff26c..c350e1f8 100644
--- a/lib/lib/command.ml
+++ b/lib/lib/command.ml
@@ -102,21 +102,21 @@ module rec Toplevel : sig
   val exec : ?theory:theory -> loop_fn:(unit -> unit) -> prog -> unit
 end = struct
   let exec ?(theory = vanilla_theory) ~loop_fn prog =
-    let module Theory = (val Theory.make theory : Theory.S) in
-    let module Command = Make (Theory) in
+    let k = Kernel.make theory in
+    let module Command = Make ((val k : KernelExt.S)) in
     Command.exec ~loop_fn prog
 end
 
-and Make : functor (CurrentTheory : Theory.S) -> sig
+and Make : functor (K : KernelExt.S) -> sig
   val exec : loop_fn:(unit -> unit) -> prog -> unit
 end =
 functor
-  (CurrentTheory : Theory.S)
+  (K : KernelExt.S)
   ->
   struct
-    module CurrentEnvironment = Environments.Make (CurrentTheory)
-    module Elaborate = Elaborate.Make (CurrentEnvironment)
-    open CurrentEnvironment
+    module Environment = Environments.Make (K)
+    module Elaborate = Elaborate.Make (Environment)
+    open Environment.K
 
     let postprocess_fn : (ctx -> tm -> ctx * tm) ref = ref (fun c e -> (c, e))
 
@@ -189,7 +189,7 @@ functor
           | NotAnInt v -> Error.wrong_option_argument ~expected:"int" o v
           | NotABoolean v -> Error.wrong_option_argument ~expected:"boolean" o v
           )
-      | SetTheory s -> exec_set_theory CurrentTheory.theory s
+      | SetTheory s -> exec_set_theory K.theory s
       | Check_builtin b ->
           Io.command "check %s" (Raw.string_of_builtin b);
           let e, ty = exec_check_builtin b in
@@ -219,9 +219,9 @@ functor
           let e, _ = exec_check_builtin b in
           let e =
             match e with
-            | Environment.Coh _ ->
+            | VCoh _ ->
                 Error.fatal "bechmarking a builtin resolving to a coherence"
-            | Environment.Tm e -> Tm.develop e
+            | VTm e -> Tm.develop e
           in
           Io.info
             (lazy
@@ -229,14 +229,12 @@ functor
                  (Printing.print_kolmogorov e)));
           KeepGoing
 
-    let initialise () = Cubical_composite.init ()
+    let initialise () = Environment.Cubical_composite.init ()
 
     let exec ~loop_fn prog =
       initialise ();
       let rec aux = function
-        | [] ->
-            Environments.store_environment
-              (module CurrentEnvironment : Environments.S)
+        | [] -> ()
         | t :: l -> (
             let next =
               try exec_cmd t with
@@ -252,10 +250,7 @@ functor
             | KeepGoing -> aux l
             | Abort -> exit 1
             | Interactive -> loop_fn ()
-            | ChangeTheory t ->
-                Environments.store_environment
-                  (module CurrentEnvironment : Environments.S);
-                Toplevel.exec ~theory:t ~loop_fn l)
+            | ChangeTheory t -> Toplevel.exec ~theory:t ~loop_fn l)
       in
       aux prog
   end
diff --git a/lib/lib/common.ml b/lib/lib/common.ml
index ef236791..6140ea71 100644
--- a/lib/lib/common.ml
+++ b/lib/lib/common.ml
@@ -49,132 +49,6 @@ end
 
 type pp_data = string * int * (Var.t * int) list list
 
-(* module type KernelS = sig *)
-(*   type tm *)
-(*   type ty *)
-(*   type ctx *)
-(*   type sub *)
-(*   type sub_ps *)
-(*   type constr *)
-
-(*   module rec Coh : sig *)
-(*     type t *)
-(*     type innertm = Tm.t *)
-
-(*     val ps : t -> PS.t *)
-(*     val forget : t -> ps * ty * pp_data *)
-(*     val suspend : t -> t *)
-(*     val is_equal : t -> t -> bool *)
-(*     val check_equal : t -> t -> unit *)
-(*     val is_inv : t -> bool *)
-(*     val to_string : ?unroll:bool -> t -> string *)
-(*     val dim : t -> int *)
-(*     val src : t -> tm *)
-(*     val tgt : t -> tm *)
-(*     val check : ps -> ty -> pp_data -> t *)
-(*     val ty : t -> Ty.t *)
-(*     val check_noninv : ps -> tm -> tm -> pp_data -> t *)
-(*     val check_inv : ps -> tm -> tm -> pp_data -> t *)
-(*     val noninv_srctgt : t -> tm * tm * ty *)
-(*     val func_data : t -> (Var.t * int) list list *)
-(*     val apply_ps : (ps -> ps) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t *)
-
-(*     val apply : *)
-(*       (ctx -> ctx) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t * sub *)
-(*   end *)
-
-(*   and Ty : sig *)
-(*     type t = private { c : Ctx.t; e : expr; unchecked : ty } *)
-(*     and expr = Obj | Arr of t * Tm.t * Tm.t *)
-(*   end *)
-
-(*   and Tm : sig *)
-(*     type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t *)
-(*     and t *)
-
-(*     val ty : t -> ty *)
-(*     val forget : t -> tm *)
-(*     val constr : t -> constr *)
-(*     val ctx : t -> ctx *)
-(*     val name : t -> string option *)
-(*     val full_name : t -> string option *)
-(*     val func_data : t -> (Var.t * int) list list option *)
-(*     val of_coh : Coh.t -> t *)
-(*     val develop : t -> tm *)
-(*     val pp_data : t -> pp_data option *)
-(*     val to_string : t -> string *)
-(*     val is_equal : t -> t -> bool *)
-(*     val check : ctx -> ?ty:ty -> ?name:pp_data -> tm -> t *)
-
-(*     val apply : *)
-(*       (ctx -> ctx) -> (tm -> tm) -> (pp_data -> pp_data) -> t -> t * sub *)
-(*   end *)
-
-(*   and Sub : sig *)
-(*     type t *)
-(*   end *)
-
-(*   and Ctx : sig *)
-(*     type t *)
-
-(*     val check : ctx -> t *)
-(*   end *)
-
-(*   and PS : sig *)
-(*     exception Invalid *)
-
-(*     type t = ps *)
-
-(*     val mk : Ctx.t -> t *)
-(*   end *)
-(* end *)
-
-(* module type SyntaxS = sig *)
-(*   type checked_tm *)
-(*   type checked_coh *)
-
-(*   type ty = Meta_ty of int | Obj | Arr of ty * tm * tm *)
-
-(*   and tm = *)
-(*     | Var : Var.t -> tm *)
-(*     | Meta_tm : int -> tm *)
-(*     | Coh : *)
-(*         (module KernelS *)
-(*            with type tm = tm *)
-(*             and type ty = ty *)
-(*             and type ctx = ctx *)
-(*             and type sub = sub *)
-(*             and type sub_ps = sub_ps *)
-(*             and type constr = constr *)
-(*             and type Coh.t = checked_coh *)
-(*             and type Tm.t = checked_tm) *)
-(*         * checked_coh *)
-(*         * sub_ps *)
-(*         -> tm *)
-(*     | App : *)
-(*         (module KernelS *)
-(*            with type tm = tm *)
-(*             and type ty = ty *)
-(*             and type ctx = ctx *)
-(*             and type sub = sub *)
-(*             and type sub_ps = sub_ps *)
-(*             and type constr = constr *)
-(*             and type Coh.t = checked_coh *)
-(*             and type Tm.t = checked_tm) *)
-(*         * checked_tm *)
-(*         * sub *)
-(*         -> tm *)
-
-(*   and sub_ps = (tm * bool) list *)
-(*   and sub = (Var.t * (tm * bool)) list *)
-(*   and ctx = (Var.t * (ty * bool)) list *)
-(*   and constr = tm * ty *)
-
-(*   type meta_ctx = (int * ty) list *)
-(*   type value = VCoh of checked_coh | VTm of checked_tm *)
-(*   type decls = (value * string) list *)
-(* end *)
-
 type ('a, 'b) pty =
   | Meta_ty of int
   | Obj
@@ -191,117 +65,7 @@ and ('a, 'b) psub = (Var.t * (('a, 'b) ptm * bool)) list
 
 type ('a, 'b) pctx = (Var.t * (('a, 'b) pty * bool)) list
 type ('a, 'b) pconstr = ('a, 'b) ptm * ('a, 'b) pty
-
-module type KernelS = sig
-  module rec Coh : sig
-    type t
-    type innertm = Tm.t
-
-    val ps : t -> PS.t
-    val forget : t -> ps * (Coh.t, Tm.t) pty * pp_data
-    val suspend : t -> t
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val is_inv : t -> bool
-    val to_string : ?unroll:bool -> t -> string
-    val dim : t -> int
-    val src : t -> (Coh.t, Tm.t) ptm
-    val tgt : t -> (Coh.t, Tm.t) ptm
-    val check : ps -> (Coh.t, Tm.t) pty -> pp_data -> t
-    val ty : t -> Ty.t
-
-    val check_noninv :
-      ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
-
-    val check_inv : ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
-
-    val noninv_srctgt :
-      t -> (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) pty
-
-    val func_data : t -> (Var.t * int) list list
-
-    val apply_ps :
-      (ps -> ps) ->
-      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t
-
-    val apply :
-      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
-      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) psub
-  end
-
-  and Ty : sig
-    type t
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-  end
-
-  and Tm : sig
-    type t
-
-    val ty : t -> (Coh.t, Tm.t) pty
-    val forget : t -> (Coh.t, Tm.t) ptm
-    val constr : t -> (Coh.t, Tm.t) pconstr
-    val ctx : t -> (Coh.t, Tm.t) pctx
-    val name : t -> string option
-    val full_name : t -> string option
-    val func_data : t -> (Var.t * int) list list option
-    val of_coh : Coh.t -> t
-    val develop : t -> (Coh.t, Tm.t) ptm
-    val pp_data : t -> pp_data option
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-
-    val check :
-      (Coh.t, Tm.t) pctx ->
-      ?ty:(Coh.t, Tm.t) pty ->
-      ?name:pp_data ->
-      (Coh.t, Tm.t) ptm ->
-      t
-
-    val apply :
-      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
-      ((Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) psub
-  end
-
-  and PS : sig
-    type t = ps
-    type inner_ctx
-
-    val mk : inner_ctx -> t
-  end
-
-  module Ctx : sig
-    type t
-
-    val check : (Coh.t, Tm.t) pctx -> t
-    val to_string : t -> string
-    val forget : t -> (Coh.t, Tm.t) pctx
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-  end
-
-  module Sub : sig
-    type t
-  end
-
-  type ty = (Coh.t, Tm.t) pty
-  type tm = (Coh.t, Tm.t) ptm
-  type sub = (Coh.t, Tm.t) psub
-  type sub_ps = (Coh.t, Tm.t) psub_ps
-  type ctx = (Coh.t, Tm.t) pctx
-  type constr = (Coh.t, Tm.t) pconstr
-  type meta_ctx = (int * ty) list
-  type value = VCoh of Coh.t | VTm of Tm.t
-  type decls = (value * string) list
-end
+type ('a, 'b) pvalue = VCoh of 'a | VTm of 'b
 
 let rec take n l =
   match l with h :: t when n > 0 -> h :: take (n - 1) t | _ -> []
diff --git a/lib/lib/common.mli b/lib/lib/common.mli
index 4f098a95..34552edd 100644
--- a/lib/lib/common.mli
+++ b/lib/lib/common.mli
@@ -23,132 +23,6 @@ end
 
 type pp_data = string * int * (Var.t * int) list list
 
-(* module type KernelS = sig *)
-(*   type tm *)
-(*   type ty *)
-(*   type ctx *)
-(*   type sub *)
-(*   type sub_ps *)
-(*   type constr *)
-
-(*   module rec Coh : sig *)
-(*     type t *)
-(*     type innertm = Tm.t *)
-
-(*     val ps : t -> PS.t *)
-(*     val forget : t -> ps * ty * pp_data *)
-(*     val suspend : t -> t *)
-(*     val is_equal : t -> t -> bool *)
-(*     val check_equal : t -> t -> unit *)
-(*     val is_inv : t -> bool *)
-(*     val to_string : ?unroll:bool -> t -> string *)
-(*     val dim : t -> int *)
-(*     val src : t -> tm *)
-(*     val tgt : t -> tm *)
-(*     val check : ps -> ty -> pp_data -> t *)
-(*     val ty : t -> Ty.t *)
-(*     val check_noninv : ps -> tm -> tm -> pp_data -> t *)
-(*     val check_inv : ps -> tm -> tm -> pp_data -> t *)
-(*     val noninv_srctgt : t -> tm * tm * ty *)
-(*     val func_data : t -> (Var.t * int) list list *)
-(*     val apply_ps : (ps -> ps) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t *)
-
-(*     val apply : *)
-(*       (ctx -> ctx) -> (ty -> ty) -> (pp_data -> pp_data) -> t -> t * sub *)
-(*   end *)
-
-(*   and Ty : sig *)
-(*     type t = private { c : Ctx.t; e : expr; unchecked : ty } *)
-(*     and expr = Obj | Arr of t * Tm.t * Tm.t *)
-(*   end *)
-
-(*   and Tm : sig *)
-(*     type expr = Var of Var.t | Coh of Coh.t * Sub.t | App of Tm.t * Sub.t *)
-(*     and t *)
-
-(*     val ty : t -> ty *)
-(*     val forget : t -> tm *)
-(*     val constr : t -> constr *)
-(*     val ctx : t -> ctx *)
-(*     val name : t -> string option *)
-(*     val full_name : t -> string option *)
-(*     val func_data : t -> (Var.t * int) list list option *)
-(*     val of_coh : Coh.t -> t *)
-(*     val develop : t -> tm *)
-(*     val pp_data : t -> pp_data option *)
-(*     val to_string : t -> string *)
-(*     val is_equal : t -> t -> bool *)
-(*     val check : ctx -> ?ty:ty -> ?name:pp_data -> tm -> t *)
-
-(*     val apply : *)
-(*       (ctx -> ctx) -> (tm -> tm) -> (pp_data -> pp_data) -> t -> t * sub *)
-(*   end *)
-
-(*   and Sub : sig *)
-(*     type t *)
-(*   end *)
-
-(*   and Ctx : sig *)
-(*     type t *)
-
-(*     val check : ctx -> t *)
-(*   end *)
-
-(*   and PS : sig *)
-(*     exception Invalid *)
-
-(*     type t = ps *)
-
-(*     val mk : Ctx.t -> t *)
-(*   end *)
-(* end *)
-
-(* module type SyntaxS = sig *)
-(*   type checked_tm *)
-(*   type checked_coh *)
-
-(*   type ty = Meta_ty of int | Obj | Arr of ty * tm * tm *)
-
-(*   and tm = *)
-(*     | Var : Var.t -> tm *)
-(*     | Meta_tm : int -> tm *)
-(*     | Coh : *)
-(*         (module KernelS *)
-(*            with type tm = tm *)
-(*             and type ty = ty *)
-(*             and type ctx = ctx *)
-(*             and type sub = sub *)
-(*             and type sub_ps = sub_ps *)
-(*             and type constr = constr *)
-(*             and type Coh.t = checked_coh *)
-(*             and type Tm.t = checked_tm) *)
-(*         * checked_coh *)
-(*         * sub_ps *)
-(*         -> tm *)
-(*     | App : *)
-(*         (module KernelS *)
-(*            with type tm = tm *)
-(*             and type ty = ty *)
-(*             and type ctx = ctx *)
-(*             and type sub = sub *)
-(*             and type sub_ps = sub_ps *)
-(*             and type constr = constr *)
-(*             and type Coh.t = checked_coh *)
-(*             and type Tm.t = checked_tm) *)
-(*         * checked_tm *)
-(*         * sub *)
-(*         -> tm *)
-
-(*   and sub_ps = (tm * bool) list *)
-(*   and sub = (Var.t * (tm * bool)) list *)
-(*   and ctx = (Var.t * (ty * bool)) list *)
-(*   and constr = tm * ty *)
-
-(*   type meta_ctx = (int * ty) list *)
-(*   type value = VCoh of checked_coh | VTm of checked_tm *)
-(*   type decls = (value * string) list *)
-(* end *)
-
 type ('a, 'b) pty =
   | Meta_ty of int
   | Obj
@@ -165,117 +39,7 @@ and ('a, 'b) psub = (Var.t * (('a, 'b) ptm * bool)) list
 
 type ('a, 'b) pctx = (Var.t * (('a, 'b) pty * bool)) list
 type ('a, 'b) pconstr = ('a, 'b) ptm * ('a, 'b) pty
-
-module type KernelS = sig
-  module rec Coh : sig
-    type t
-    type innertm = Tm.t
-
-    val ps : t -> PS.t
-    val forget : t -> ps * (Coh.t, Tm.t) pty * pp_data
-    val suspend : t -> t
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-    val is_inv : t -> bool
-    val to_string : ?unroll:bool -> t -> string
-    val dim : t -> int
-    val src : t -> (Coh.t, Tm.t) ptm
-    val tgt : t -> (Coh.t, Tm.t) ptm
-    val check : ps -> (Coh.t, Tm.t) pty -> pp_data -> t
-    val ty : t -> Ty.t
-
-    val check_noninv :
-      ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
-
-    val check_inv : ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
-
-    val noninv_srctgt :
-      t -> (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) pty
-
-    val func_data : t -> (Var.t * int) list list
-
-    val apply_ps :
-      (ps -> ps) ->
-      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t
-
-    val apply :
-      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
-      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) psub
-  end
-
-  and Ty : sig
-    type t
-    and expr = Obj | Arr of t * Tm.t * Tm.t
-  end
-
-  and Tm : sig
-    type t
-
-    val ty : t -> (Coh.t, Tm.t) pty
-    val forget : t -> (Coh.t, Tm.t) ptm
-    val constr : t -> (Coh.t, Tm.t) pconstr
-    val ctx : t -> (Coh.t, Tm.t) pctx
-    val name : t -> string option
-    val full_name : t -> string option
-    val func_data : t -> (Var.t * int) list list option
-    val of_coh : Coh.t -> t
-    val develop : t -> (Coh.t, Tm.t) ptm
-    val pp_data : t -> pp_data option
-    val to_string : t -> string
-    val is_equal : t -> t -> bool
-
-    val check :
-      (Coh.t, Tm.t) pctx ->
-      ?ty:(Coh.t, Tm.t) pty ->
-      ?name:pp_data ->
-      (Coh.t, Tm.t) ptm ->
-      t
-
-    val apply :
-      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
-      ((Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm) ->
-      (pp_data -> pp_data) ->
-      t ->
-      t * (Coh.t, Tm.t) psub
-  end
-
-  and PS : sig
-    type t = ps
-    type inner_ctx
-
-    val mk : inner_ctx -> t
-  end
-
-  module Ctx : sig
-    type t
-
-    val check : (Coh.t, Tm.t) pctx -> t
-    val to_string : t -> string
-    val forget : t -> (Coh.t, Tm.t) pctx
-    val is_equal : t -> t -> bool
-    val check_equal : t -> t -> unit
-  end
-
-  module Sub : sig
-    type t
-  end
-
-  type ty = (Coh.t, Tm.t) pty
-  type tm = (Coh.t, Tm.t) ptm
-  type sub = (Coh.t, Tm.t) psub
-  type sub_ps = (Coh.t, Tm.t) psub_ps
-  type ctx = (Coh.t, Tm.t) pctx
-  type constr = (Coh.t, Tm.t) pconstr
-  type meta_ctx = (int * ty) list
-  type value = VCoh of Coh.t | VTm of Tm.t
-  type decls = (value * string) list
-end
+type ('a, 'b) pvalue = VCoh of 'a | VTm of 'b
 
 val take : int -> 'a list -> 'a list
 
diff --git a/lib/lib/environments.ml b/lib/lib/environments.ml
index 0b235afe..a5214e47 100644
--- a/lib/lib/environments.ml
+++ b/lib/lib/environments.ml
@@ -2,163 +2,157 @@ open Common
 open Raw_types
 
 module type S = sig
-  module CurrentTheory : Theory.S
-  include module type of Kernel.Make (CurrentTheory)
-
-  module Environment : sig
-    type value = Coh of Coh.t | Tm of Tm.t
-    type t
-
-    val builtin_to_value : Raw_types.builtin -> value
-    val value_ty : value -> ty
-    val value_to_string : value -> string
-    val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
-    val add_value : Var.t -> value -> value * ty
-    val add_coh : Var.t -> ps -> ty -> Coh.t
-    val val_var : Var.t -> value
-    val dim_output : Var.t -> int
-    val dim_input : Var.t -> int
-    val forall : (Var.t -> unit) -> unit
-  end
-
-  module Suspension : module type of Suspension.Make (CurrentTheory)
-
-  module Functorialisation :
-      module type of Functorialisation.Make (CurrentTheory)
-
-  module Opposite : module type of Opposite.Make (CurrentTheory)
-  module Inverse : module type of Inverse.Make (CurrentTheory)
-  module Builtin : module type of Builtin.Make (CurrentTheory)
-  module Cones : module type of Cones.Make (CurrentTheory)
-  module Cylinders : module type of Cylinders.Make (CurrentTheory)
-  module Eh : module type of Eh.Make (CurrentTheory)
-
-  module Cubical_composite :
-      module type of Cubical_composite.Make (CurrentTheory)
+  module K : KernelExt.S
+  open K
+
+  val builtin_to_value : Raw_types.builtin -> value
+  val value_ty : value -> ty
+  val value_to_string : value -> string
+  val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
+  val add_value : Var.t -> value -> value * ty
+  val add_coh : Var.t -> ps -> ty -> Coh.t
+  val val_var : Var.t -> value
+  val dim_output : Var.t -> int
+  val dim_input : Var.t -> int
+
+  module Suspension : module type of Suspension.Make (K)
+  module Functorialisation : module type of Functorialisation.Make (K)
+  module Opposite : module type of Opposite.Make (K)
+  module Inverse : module type of Inverse.Make (K)
+  module Builtin : module type of Builtin.Make (K)
+  module Cones : module type of Cones.Make (K)
+  module Cylinders : module type of Cylinders.Make (K)
+  module Eh : module type of Eh.Make (K)
+  module Cubical_composite : module type of Cubical_composite.Make (K)
 end
 
-let known_environments : (Var.t, (module S) list) Hashtbl.t = Hashtbl.create 77
-
-let update_known_environments (v : Var.t) env =
-  let module Env = (val env : S) in
-  let list = Hashtbl.find_opt known_environments v in
-  match list with
-  | None -> Hashtbl.add known_environments v [ env ]
-  | Some list ->
-      let rec replace list =
-        match list with
-        | [] -> [ env ]
-        | known_env :: list ->
-            let module KnownEnv = (val known_env : S) in
-            if KnownEnv.CurrentTheory.theory == Env.CurrentTheory.theory then
-              env :: list
-            else known_env :: replace list
-      in
-      Hashtbl.replace known_environments v (replace list)
-
-let store_environment environment =
-  let open (val environment : S) in
-  Environment.forall (fun v -> update_known_environments v environment)
-
-let find_environment v = Hashtbl.find known_environments v
-
-module Make (CurrentTheory : Theory.S) = struct
-  module CurrentTheory = CurrentTheory
-  include Kernel.Make (CurrentTheory)
-  module Suspension = Suspension.Make (CurrentTheory)
-  module Functorialisation = Functorialisation.Make (CurrentTheory)
-  module Opposite = Opposite.Make (CurrentTheory)
-  module Inverse = Inverse.Make (CurrentTheory)
-  module Builtin = Builtin.Make (CurrentTheory)
-  module Cones = Cones.Make (CurrentTheory)
-  module Cylinders = Cylinders.Make (CurrentTheory)
-  module Eh = Eh.Make (CurrentTheory)
-  module Cubical_composite = Cubical_composite.Make (CurrentTheory)
-
-  let () =
-    if !CurrentTheory.environment_created then
-      Error.fatal "Environment already created for the theory"
-    else CurrentTheory.environment_created := true
-
-  module Environment = struct
-    type value = Coh of Coh.t | Tm of Tm.t
-
-    let builtin_to_value b =
-      match b with
-      | Comp -> Coh (Builtin.comp_n 1)
-      | Id -> Coh (Builtin.id ())
-      | Conecomp (n, k, m) -> Tm (Cones.compose n m k)
-      | Cylcomp (n, k, m) -> Tm (Cylinders.compose n m k)
-      | Cylstack n -> Tm (Cylinders.stacking n)
-      | Eh_half (n, k, l) -> Tm (Eh.eh n k l)
-      | Eh_full (n, k, l) -> Tm (Eh.full_eh n k l)
-
-    let value_ty v =
-      match v with
-      | Coh c ->
-          let _, ty, _ = Coh.forget c in
-          ty
-      | Tm t -> Tm.ty t
-
-    let value_ctx v =
-      match v with
-      | Coh c ->
-          let ps, _, _ = Coh.forget c in
-          Unchecked.ps_to_ctx ps
-      | Tm t -> Tm.ctx t
-
-    let value_to_string v =
-      match v with Coh c -> Coh.to_string c | Tm t -> Tm.to_string t
-
-    type v = { value : value; dim_input : int; dim_output : int }
-    type t = (Var.t, v) Hashtbl.t
-
-    let env : t = Hashtbl.create 70
-
-    let add_let v c ?ty t =
-      try
-        let pp_data = (Var.to_string v, 0, []) in
-        let kc = Ctx.check c in
-        let tm = check_term kc ?ty ~name:pp_data t in
-        let ty = tm.ty.unchecked in
-        let dim_input = Unchecked.dim_ctx c in
-        let dim_output = Unchecked.dim_ty ty in
-        Io.info ~v:4
-          (lazy
-            (Printf.sprintf "term %s of type %s added to environment"
-               (Printing.tm_to_string t) (Printing.ty_to_string ty)));
-        Hashtbl.add env v { value = Tm tm; dim_input; dim_output };
-        (t, ty)
-      with DoubledVar x -> Error.doubled_var (Printing.ctx_to_string c) x
-
-    let add_coh v ps ty =
-      let coh = check_coh ps ty (Var.to_string v, 0, []) in
-      let dim_input = Unchecked.dim_ps ps in
-      let dim_output = Unchecked.dim_ty ty in
-      Io.info ~v:4
-        (lazy
-          (Printf.sprintf "coherence %s added to environment" (Var.to_string v)));
-      Hashtbl.add env v { value = Coh coh; dim_input; dim_output };
-      coh
-
-    let find v =
-      try Hashtbl.find env v
-      with Not_found -> raise (Error.UnknownId (Var.to_string v))
-
-    let add_value v value =
-      let ty = value_ty value in
-      let dim_input = Unchecked.dim_ctx (value_ctx value) in
-      let dim_output = Unchecked.dim_ty ty in
-      Io.info ~v:4
-        (lazy
-          (Printf.sprintf "term %s of type %s added to environment"
-             (value_to_string value) (Printing.ty_to_string ty)));
-      Hashtbl.add env v { value; dim_input; dim_output };
-      (value, ty)
-
-    let val_var v = (find v).value
-    let dim_output v = (find v).dim_output
-    let dim_input v = (find v).dim_input
-    let forall f = Hashtbl.iter (fun x _ -> f x) env
-  end
+type envValue =
+  | Val :
+      (module KernelExt.S with type Coh.t = 'a and type Tm.t = 'b)
+      * ('a, 'b) pvalue
+      -> envValue
+
+module Value (K : KernelExt.S) = struct
+  open K
+  module Builtin = Builtin.Make (K)
+  module Cones = Cones.Make (K)
+  module Cylinders = Cylinders.Make (K)
+  module Eh = Eh.Make (K)
+
+  let value_ty v =
+    match v with
+    | VCoh c ->
+        let _, ty, _ = Coh.forget c in
+        ty
+    | VTm t -> Tm.ty t
+
+  let value_to_string v =
+    match v with VCoh c -> Coh.to_string c | VTm t -> Tm.to_string t
+end
+
+type v = { value : envValue; dim_input : int; dim_output : int }
+type t = (Var.t, v) Hashtbl.t
+
+let env : t = Hashtbl.create 70
+
+let add v value =
+  let dim_input, dim_output =
+    match value with
+    | Val ((module K), VTm t) ->
+        (K.Unchecked.dim_ctx (K.Tm.ctx t), K.Unchecked.dim_ty (K.Tm.ty t))
+    | Val ((module K), VCoh c) ->
+        let ps, ty, _ = K.Coh.forget c in
+        (K.Unchecked.dim_ps ps, K.Unchecked.dim_ty ty)
+  in
+  Io.info ~v:4
+    (lazy (Printf.sprintf "Value %s added to environment" (Var.to_string v)));
+  Hashtbl.add env v { value; dim_input; dim_output }
+
+let find_infos v =
+  try Hashtbl.find_all env v
+  with Not_found -> raise (Error.UnknownId (Var.to_string v))
+
+let find v = List.map (fun v -> v.value) (find_infos v)
+
+module Make (K : KernelExt.S) = struct
+  module K = K
+  open K
+  module Suspension = Suspension.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
+  module Opposite = Opposite.Make (K)
+  module Inverse = Inverse.Make (K)
+  module Builtin = Builtin.Make (K)
+  module Cones = Cones.Make (K)
+  module Cylinders = Cylinders.Make (K)
+  module Eh = Eh.Make (K)
+  module Cubical_composite = Cubical_composite.Make (K)
+  module Value = Value (K)
+
+  let builtin_to_value b =
+    match b with
+    | Comp -> VCoh (Builtin.comp_n 1)
+    | Id -> VCoh (Builtin.id ())
+    | Conecomp (n, k, m) -> VTm (Cones.compose n m k)
+    | Cylcomp (n, k, m) -> VTm (Cylinders.compose n m k)
+    | Cylstack n -> VTm (Cylinders.stacking n)
+    | Eh_half (n, k, l) -> VTm (Eh.eh n k l)
+    | Eh_full (n, k, l) -> VTm (Eh.full_eh n k l)
+
+  let value_ty = Value.value_ty
+  let value_to_string = Value.value_to_string
+
+  let add_let v c ?ty t =
+    try
+      let pp_data = (Var.to_string v, 0, []) in
+      let kc = Ctx.check c in
+      let tm = check_term kc ?ty ~name:pp_data t in
+      let ty = Tm.ty tm in
+      add v
+        (Val
+           ( (module K : KernelExt.S with type Coh.t = Coh.t and type Tm.t = Tm.t),
+             VTm tm ));
+      (t, ty)
+    with DoubledVar x -> Error.doubled_var (Printing.ctx_to_string c) x
+
+  let add_coh v ps ty =
+    let coh = check_coh ps ty (Var.to_string v, 0, []) in
+    add v
+      (Val
+         ( (module K : KernelExt.S with type Coh.t = Coh.t and type Tm.t = Tm.t),
+           VCoh coh ));
+    coh
+
+  let add_value v value =
+    let ty = Value.value_ty value in
+    add v
+      (Val
+         ( (module K : KernelExt.S with type Coh.t = Coh.t and type Tm.t = Tm.t),
+           value ));
+    (value, ty)
+
+  (* INVARIANT: There is always at most one kernel for a single theory, so if
+  we find in the environment a kernel with the same theory as the ambient one,
+  it is the same, hence the use of Obj.magic *)
+  let find v =
+    let rec find_theory l =
+      match l with
+      | [] -> raise (Error.UnknownId (Var.to_string v))
+      | [ { value = Val ((module K'), value); dim_output; dim_input } ]
+        when K'.theory = K.theory ->
+          (Obj.magic value, dim_output, dim_input)
+      | _ :: l -> find_theory l
+    in
+    find_theory (find_infos v)
+
+  let val_var v =
+    let value, _, _ = find v in
+    value
+
+  let dim_output v =
+    let _, d, _ = find v in
+    d
+
+  let dim_input v =
+    let _, _, d = find v in
+    d
 end
diff --git a/lib/lib/environments.mli b/lib/lib/environments.mli
index d912bbdb..2d443cc7 100644
--- a/lib/lib/environments.mli
+++ b/lib/lib/environments.mli
@@ -1,42 +1,36 @@
 open Common
 
 module type S = sig
-  module CurrentTheory : Theory.S
-  include module type of Kernel.Make (CurrentTheory)
-
-  module Environment : sig
-    type value = Coh of Coh.t | Tm of Tm.t
-    type t
-
-    val builtin_to_value : Raw_types.builtin -> value
-    val value_ty : value -> ty
-    val value_to_string : value -> string
-    val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
-    val add_value : Var.t -> value -> value * ty
-    val add_coh : Var.t -> ps -> ty -> Coh.t
-    val val_var : Var.t -> value
-    val dim_output : Var.t -> int
-    val dim_input : Var.t -> int
-    val forall : (Var.t -> unit) -> unit
-  end
-
-  module Suspension : module type of Suspension.Make (CurrentTheory)
-
-  module Functorialisation :
-      module type of Functorialisation.Make (CurrentTheory)
-
-  module Opposite : module type of Opposite.Make (CurrentTheory)
-  module Inverse : module type of Inverse.Make (CurrentTheory)
-  module Builtin : module type of Builtin.Make (CurrentTheory)
-  module Cones : module type of Cones.Make (CurrentTheory)
-  module Cylinders : module type of Cylinders.Make (CurrentTheory)
-  module Eh : module type of Eh.Make (CurrentTheory)
-
-  module Cubical_composite :
-      module type of Cubical_composite.Make (CurrentTheory)
+  module K : KernelExt.S
+  open K
+
+  val builtin_to_value : Raw_types.builtin -> value
+  val value_ty : value -> ty
+  val value_to_string : value -> string
+  val add_let : Var.t -> ctx -> ?ty:ty -> tm -> tm * ty
+  val add_value : Var.t -> value -> value * ty
+  val add_coh : Var.t -> ps -> ty -> Coh.t
+  val val_var : Var.t -> value
+  val dim_output : Var.t -> int
+  val dim_input : Var.t -> int
+
+  module Suspension : module type of Suspension.Make (K)
+  module Functorialisation : module type of Functorialisation.Make (K)
+  module Opposite : module type of Opposite.Make (K)
+  module Inverse : module type of Inverse.Make (K)
+  module Builtin : module type of Builtin.Make (K)
+  module Cones : module type of Cones.Make (K)
+  module Cylinders : module type of Cylinders.Make (K)
+  module Eh : module type of Eh.Make (K)
+  module Cubical_composite : module type of Cubical_composite.Make (K)
 end
 
-val store_environment : (module S) -> unit
-val find_environment : Var.t -> (module S) list
+type envValue =
+  | Val :
+      (module KernelExt.S with type Coh.t = 'a and type Tm.t = 'b)
+      * ('a, 'b) pvalue
+      -> envValue
+
+val find : Var.t -> envValue list
 
-module Make (_ : Theory.S) : S
+module Make (_ : KernelExt.S) : S
diff --git a/lib/lib/kernelExt.mli b/lib/lib/kernelExt.mli
new file mode 100644
index 00000000..1ac2c6f5
--- /dev/null
+++ b/lib/lib/kernelExt.mli
@@ -0,0 +1,133 @@
+open Common
+
+module type S = sig
+  exception InvalidPS
+
+  val theory : theory
+
+  module rec Coh : sig
+    type t
+    type innertm = Tm.t
+
+    val ps : t -> PS.t
+    val forget : t -> ps * (Coh.t, Tm.t) pty * pp_data
+    val suspend : t -> t
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+    val is_inv : t -> bool
+    val to_string : ?unroll:bool -> t -> string
+    val dim : t -> int
+    val src : t -> (Coh.t, Tm.t) ptm
+    val tgt : t -> (Coh.t, Tm.t) ptm
+    val check : ps -> (Coh.t, Tm.t) pty -> pp_data -> t
+    val ty : t -> Ty.t
+
+    val check_noninv :
+      ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
+
+    val check_inv : ps -> (Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm -> pp_data -> t
+
+    val noninv_srctgt :
+      t -> (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) ptm * (Coh.t, Tm.t) pty
+
+    val func_data : t -> (Var.t * int) list list
+
+    val apply_ps :
+      (ps -> ps) ->
+      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
+      ((Coh.t, Tm.t) pty -> (Coh.t, Tm.t) pty) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) psub
+  end
+
+  and Ty : sig
+    type t
+    and expr = Obj | Arr of t * Tm.t * Tm.t
+
+    val expr : t -> expr
+  end
+
+  and Tm : sig
+    type t
+
+    val typ : t -> Ty.t
+    val ty : t -> (Coh.t, Tm.t) pty
+    val forget : t -> (Coh.t, Tm.t) ptm
+    val constr : t -> (Coh.t, Tm.t) pconstr
+    val ctx : t -> (Coh.t, Tm.t) pctx
+    val name : t -> string option
+    val full_name : t -> string option
+    val func_data : t -> (Var.t * int) list list option
+    val of_coh : Coh.t -> t
+    val develop : t -> (Coh.t, Tm.t) ptm
+    val pp_data : t -> pp_data option
+    val to_string : t -> string
+    val is_equal : t -> t -> bool
+
+    val check :
+      (Coh.t, Tm.t) pctx ->
+      ?ty:(Coh.t, Tm.t) pty ->
+      ?name:pp_data ->
+      (Coh.t, Tm.t) ptm ->
+      t
+
+    val apply :
+      ((Coh.t, Tm.t) pctx -> (Coh.t, Tm.t) pctx) ->
+      ((Coh.t, Tm.t) ptm -> (Coh.t, Tm.t) ptm) ->
+      (pp_data -> pp_data) ->
+      t ->
+      t * (Coh.t, Tm.t) psub
+  end
+
+  and PS : sig
+    type t = ps
+    type inner_ctx = Ctx.t
+
+    val mk : inner_ctx -> t
+  end
+
+  and Ctx : sig
+    type t
+
+    val check : (Coh.t, Tm.t) pctx -> t
+    val to_string : t -> string
+    val forget : t -> (Coh.t, Tm.t) pctx
+    val is_equal : t -> t -> bool
+    val check_equal : t -> t -> unit
+  end
+
+  module Sub : sig
+    type t
+  end
+
+  type ty = (Coh.t, Tm.t) pty
+  type tm = (Coh.t, Tm.t) ptm
+  type sub = (Coh.t, Tm.t) psub
+  type sub_ps = (Coh.t, Tm.t) psub_ps
+  type ctx = (Coh.t, Tm.t) pctx
+  type constr = (Coh.t, Tm.t) pconstr
+  type meta_ctx = (int * ty) list
+  type value = (Coh.t, Tm.t) pvalue
+  type decls = (value * string) list
+
+  module Core :
+    Core.S
+      with type PS.t = PS.t
+       and type Coh.t = Coh.t
+       and type Tm.t = Tm.t
+       and type Ty.t = Ty.t
+
+  include module type of Syntax.Make (Core)
+
+  val check_term : Ctx.t -> ?ty:ty -> ?name:pp_data -> tm -> Tm.t
+  val check_constr : ?name:pp_data -> ctx -> constr -> Tm.t
+  val check_coh : ps -> ty -> pp_data -> Coh.t
+  val check_sub : ctx -> sub -> ctx -> unit
+end
diff --git a/lib/lib/meta.mli b/lib/lib/meta.mli
index 9f73b8da..7fa0dcb6 100644
--- a/lib/lib/meta.mli
+++ b/lib/lib/meta.mli
@@ -1,4 +1,4 @@
 open Common
 
-val new_ty : unit -> ('a, 'b) ty
-val new_tm : unit -> ('a, 'b) tm * (int * ('a, 'b) ty)
+val new_ty : unit -> ('a, 'b) pty
+val new_tm : unit -> ('a, 'b) ptm * (int * ('a, 'b) pty)
diff --git a/lib/lib/raw.ml b/lib/lib/raw.ml
index 54daa514..f7e1a8c9 100644
--- a/lib/lib/raw.ml
+++ b/lib/lib/raw.ml
@@ -53,8 +53,6 @@ and string_of_functed_tm t n =
   else Printf.sprintf "[%s]" (string_of_functed_tm t (n - 1))
 
 module Make (Environment : Environments.S) = struct
-  open Environment
-
   (** remove the let in in a term *)
   let rec replace_tm l e =
     match e with
diff --git a/lib/meta_operations/builtin.ml b/lib/meta_operations/builtin.ml
index 076f3f88..b6c03f8f 100644
--- a/lib/meta_operations/builtin.ml
+++ b/lib/meta_operations/builtin.ml
@@ -1,12 +1,10 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Comp = Comp.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
-
-  let mod_coh = assert false
+module Make (K : KernelExt.S) = struct
+  open K
+  module Comp = Comp.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
 
   let id _ =
     check_coh (Br []) (Arr (Obj, Var (Db 0), Var (Db 0))) ("builtin_id", 0, [])
@@ -24,7 +22,7 @@ module Make (Theory : Theory.S) = struct
       match l with
       | [] -> [ (t, false) ]
       | Br [] :: l ->
-          (Coh (mod_coh, id (), [ (t, true) ]), true) :: (t, false) :: id_map l
+          (Coh (id (), [ (t, true) ]), true) :: (t, false) :: id_map l
       | _ -> Error.fatal "identity must be inserted on maximal argument"
     in
     let rec aux i ps =
@@ -55,14 +53,12 @@ module Make (Theory : Theory.S) = struct
     let bdry = Unchecked.ps_bdry ps in
     let src =
       let coh = Coh.check_noninv ps t t ("endo", 0, []) in
-      Coh (mod_coh, coh, id_all_max ps)
+      Coh (coh, id_all_max ps)
     in
     let a = Tm.ty (check_term (Ctx.check (Unchecked.ps_to_ctx bdry)) t) in
     let da = Unchecked.dim_ty a in
     let sub_base = Unchecked.ty_to_sub_ps a in
-    let tgt =
-      Coh (mod_coh, Suspension.coh (Some da) (id ()), (t, true) :: sub_base)
-    in
+    let tgt = Coh (Suspension.coh (Some da) (id ()), (t, true) :: sub_base) in
     Coh.check_inv bdry src tgt ("unbiased_unitor", 0, [])
 
   let tdb i = Var (Var.Db i)
diff --git a/lib/meta_operations/builtin.mli b/lib/meta_operations/builtin.mli
index 20bbcb2f..0118acbf 100644
--- a/lib/meta_operations/builtin.mli
+++ b/lib/meta_operations/builtin.mli
@@ -1,8 +1,8 @@
 open Common
 open Raw_types
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val wcomp : tm * ty -> int -> tm * ty -> tm * ty
   val ps_comp : int -> ps
diff --git a/lib/meta_operations/comp.ml b/lib/meta_operations/comp.ml
index b6fc4728..c7926e46 100644
--- a/lib/meta_operations/comp.ml
+++ b/lib/meta_operations/comp.ml
@@ -1,7 +1,7 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
 
   module Memo = struct
     let tbl = Hashtbl.create 97
@@ -38,7 +38,5 @@ module Make (Theory : Theory.S) = struct
   let bcomp x y f z g =
     let comp = comp_n 2 in
     let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
-    (* TODO *)
-    let mod_coh = assert false in
-    Coh (mod_coh, comp, sub)
+    Coh (comp, sub)
 end
diff --git a/lib/meta_operations/comp.mli b/lib/meta_operations/comp.mli
index 33beb386..b6503155 100644
--- a/lib/meta_operations/comp.mli
+++ b/lib/meta_operations/comp.mli
@@ -1,8 +1,8 @@
 open Common
 open Raw_types
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val tree : int -> ps
   val x : int -> constr
diff --git a/lib/meta_operations/cones.ml b/lib/meta_operations/cones.ml
index 644f30ea..4a23d55e 100644
--- a/lib/meta_operations/cones.ml
+++ b/lib/meta_operations/cones.ml
@@ -1,15 +1,13 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-  module Construct = Construct.Make (Theory)
-  module Opposite = Opposite.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
+  module Builtin = Builtin.Make (K)
+  module Construct = Construct.Make (K)
+  module Opposite = Opposite.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
 
-  let mod_coh = assert false
-  let mod_tm = assert false
   let wcomp = Construct.wcomp
 
   (* Cone contexts *)
@@ -217,7 +215,7 @@ module Make (Theory : Theory.S) = struct
       let assoc = Builtin.assoc in
       let _, assoc_ty, _ = Coh.forget assoc in
       let tm_2 =
-        ( Coh (mod_coh, Builtin.assoc, sub_ps),
+        ( Coh (Builtin.assoc, sub_ps),
           Unchecked.ty_apply_sub assoc_ty (Unchecked.sub_ps_to_sub sub_ps) )
       in
       let tm, _ = wcomp tm_1 1 tm_2 in
@@ -280,7 +278,7 @@ module Make (Theory : Theory.S) = struct
                    (Opposite.sub (Cone.bdry_left (n - 1) (n - 2)) op_data))
             in
             check_term (Ctx.check ctx_comp) ~name:(name, 0, [])
-              (App (mod_tm, comp, sub))
+              (App (comp, sub))
           in
           let intch = intch n in
           let socomp = (Tm.develop suspopcomp, Tm.ty suspopcomp) in
diff --git a/lib/meta_operations/cones.mli b/lib/meta_operations/cones.mli
index 3654d633..48eb8540 100644
--- a/lib/meta_operations/cones.mli
+++ b/lib/meta_operations/cones.mli
@@ -1,5 +1,5 @@
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val compose : int -> int -> int -> Tm.t
 end
diff --git a/lib/meta_operations/construct.ml b/lib/meta_operations/construct.ml
index f29c2acf..f71b7a7f 100644
--- a/lib/meta_operations/construct.ml
+++ b/lib/meta_operations/construct.ml
@@ -1,15 +1,13 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
-  module Opposite = Opposite.Make (Theory)
-  module Inverse = Inverse.Make (Theory)
-
-  let mod_coh = assert false
-  let mod_tm = assert false
+module Make (K : KernelExt.S) = struct
+  open K
+  module Builtin = Builtin.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
+  module Opposite = Opposite.Make (K)
+  module Inverse = Inverse.Make (K)
+
   let to_tm (tm, _) = tm
   let to_ty (_, ty) = ty
   let characteristic_sub_ps (tm, ty) = (tm, true) :: Unchecked.ty_to_sub_ps ty
@@ -46,21 +44,19 @@ module Make (Theory : Theory.S) = struct
     in
     let ps, ty, _ = Coh.forget coh in
     let sub = elaborate ps tms in
-    (* TODO *)
-    let mod_coh = assert false in
-    (Coh (mod_coh, coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
 
   let of_coh coh =
     let ps, ty, _ = Coh.forget coh in
     let id = Unchecked.identity_ps ps in
-    (Coh (mod_coh, coh, id), ty)
+    (Coh (coh, id), ty)
 
   let make_sub ctx list =
     List.map2 (fun (x, (_, b)) t -> (x, (fst t, b))) ctx list
 
   let tm_app_sub tm sub =
     let ty = Tm.ty tm in
-    (App (mod_tm, tm, sub), Unchecked.ty_apply_sub ty sub)
+    (App (tm, sub), Unchecked.ty_apply_sub ty sub)
 
   let of_tm tm =
     let c = Tm.ctx tm in
@@ -105,7 +101,7 @@ module Make (Theory : Theory.S) = struct
     let whisk = whisk3 n j k l in
     let whisk_sub_ps = whisk3_sub_ps k f fty g gty l h hty in
     let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-    ( App (mod_tm, whisk, whisk_sub),
+    ( App (whisk, whisk_sub),
       Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
 
   let intch_comp_nm a b c =
@@ -123,7 +119,7 @@ module Make (Theory : Theory.S) = struct
     let coh = Builtin.intch_comp_nm_coh n m in
     let sub = sub_right @ sub_left in
     let _, ty, _ = Coh.forget coh in
-    (Coh (mod_coh, coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
 
   let intch_comp_mn a b c =
     let m = Unchecked.dim_ty (snd a) in
@@ -139,17 +135,14 @@ module Make (Theory : Theory.S) = struct
     let coh = Opposite.coh coh [ 1 ] in
     let sub = sub_right @ sub_left in
     let _, ty, _ = Coh.forget coh in
-    (Coh (mod_coh, coh, sub), Unchecked.ty_apply_sub_ps ty sub)
+    (Coh (coh, sub), Unchecked.ty_apply_sub_ps ty sub)
 
   let opposite (t, ty) op_data = (Opposite.tm t op_data, Opposite.ty ty op_data)
   let inv (t, ty) = (Inverse.compute_inverse t, Inverse.ty ty)
 
   let id constr =
     let d = dim constr in
-    ( Coh
-        ( mod_coh,
-          Suspension.coh (Some d) (Builtin.id ()),
-          characteristic_sub_ps constr ),
+    ( Coh (Suspension.coh (Some d) (Builtin.id ()), characteristic_sub_ps constr),
       arr constr constr )
 
   let rec id_n n constr =
@@ -187,9 +180,7 @@ module Make (Theory : Theory.S) = struct
     let c = first constrs in
     let d = dim c in
     ( Coh
-        ( mod_tm,
-          Suspension.coh (Some (d - 1)) (Builtin.comp_n l),
-          glue_subs constrs_rev ),
+        (Suspension.coh (Some (d - 1)) (Builtin.comp_n l), glue_subs constrs_rev),
       arr (src 1 c) (tgt 1 (first constrs_rev)) )
 
   let comp c1 c2 = comp_n [ c1; c2 ]
@@ -238,7 +229,7 @@ module Make (Theory : Theory.S) = struct
       glue_subs_along k (List.map characteristic_sub_ps constrs)
     in
     let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-    ( App (mod_tm, whisk, whisk_sub),
+    ( App (whisk, whisk_sub),
       Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
 
   let witness constr =
diff --git a/lib/meta_operations/construct.mli b/lib/meta_operations/construct.mli
index bc496695..925aea67 100644
--- a/lib/meta_operations/construct.mli
+++ b/lib/meta_operations/construct.mli
@@ -1,7 +1,7 @@
 open Common
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val to_tm : constr -> tm
   val to_ty : constr -> ty
diff --git a/lib/meta_operations/cubical_composite.ml b/lib/meta_operations/cubical_composite.ml
index 3673a080..c1cd38dd 100644
--- a/lib/meta_operations/cubical_composite.ml
+++ b/lib/meta_operations/cubical_composite.ml
@@ -1,13 +1,11 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module F = Functorialisation.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Ps_reduction = Ps_reduction.Make (Theory)
-
-  let mod_coh = assert false
+module Make (K : KernelExt.S) = struct
+  open K
+  module F = Functorialisation.Make (K)
+  module Builtin = Builtin.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Ps_reduction = Ps_reduction.Make (K)
 
   module LinearComp = struct
     module Memo = struct
@@ -40,8 +38,7 @@ module Make (Theory : Theory.S) = struct
     let bcomp x y f z g =
       let comp = Builtin.comp_n 2 in
       let sub = [ (g, true); (z, false); (f, true); (y, false); (x, false) ] in
-      let mod_coh = assert false in
-      Coh (mod_coh, comp, sub)
+      Coh (comp, sub)
 
     let idx_src i = if i = 2 then 0 else i - 3
     let plus i l = if List.mem (Var.Db i) l then tpl i else tdb i
@@ -71,14 +68,12 @@ module Make (Theory : Theory.S) = struct
         in
         sub (2 * arity)
       in
-      let mod_coh = assert false in
-      let lin_comp = Coh (mod_coh, Builtin.comp_n arity, lin_incl) in
+      let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
       bcomp (tdb 0) (tdb 1) (tdb 2) (tdb ((2 * arity) + 1)) lin_comp
 
     let comp_biased_end arity =
       let lin_incl = Unchecked.identity_ps (Builtin.ps_comp arity) in
-      let mod_coh = assert false in
-      let lin_comp = Coh (mod_coh, Builtin.comp_n arity, lin_incl) in
+      let lin_comp = Coh (Builtin.comp_n arity, lin_incl) in
       bcomp (tdb 0)
         (tdb ((2 * arity) - 1))
         lin_comp
@@ -105,8 +100,7 @@ module Make (Theory : Theory.S) = struct
             (tdb (k + 2), true) :: (tdb (k + 1), false) :: sub (k - 2)
         | _ -> assert false
       in
-      let mod_coh = assert false in
-      Coh (mod_coh, comp, sub (2 * arity))
+      Coh (comp, sub (2 * arity))
 
     let comp_biased arity pos =
       match pos with
@@ -159,8 +153,7 @@ module Make (Theory : Theory.S) = struct
       let assc = Coh.check_inv ps src tgt ("builtin_assc", 0, []) in
       let sub = sub_assc_i i arity l in
       let _, ty, _ = Coh.forget assc in
-      let mod_coh = assert false in
-      (Coh (mod_coh, assc, sub), Unchecked.ty_apply_sub_ps ty sub)
+      (Coh (assc, sub), Unchecked.ty_apply_sub_ps ty sub)
 
     let whsk i arity l =
       let src = src_i_f i (List.mem (Var.Db (i - 1)) l) in
@@ -169,8 +162,7 @@ module Make (Theory : Theory.S) = struct
       let comp = Builtin.comp_n arity in
       let whsk = F.coh_depth0 comp [ Db i ] in
       let _, ty, _ = Coh.forget whsk in
-      let mod_coh = assert false in
-      (Coh (mod_coh, whsk, sub), Unchecked.ty_apply_sub_ps ty sub)
+      (Coh (whsk, sub), Unchecked.ty_apply_sub_ps ty sub)
 
     let move_at v l arity =
       let mv, ty =
@@ -212,8 +204,7 @@ module Make (Theory : Theory.S) = struct
       let ctx_comp = Unchecked.ps_to_ctx (Builtin.ps_comp arity) in
       let s = sub ctx_comp ~add_src:true base in
       let _, ty, _ = Coh.forget comp in
-      let mod_coh = assert false in
-      (Coh (mod_coh, comp, s), Unchecked.ty_apply_sub_ps ty s)
+      (Coh (comp, s), Unchecked.ty_apply_sub_ps ty s)
 
     let build_cubical arity list =
       match arity with
@@ -256,8 +247,7 @@ module Make (Theory : Theory.S) = struct
 
   (* Construct source (t[i1]) * (tgt_f[i2]) *)
   let naturality_src coh ty tgt ty_base dim l i1 i2 names =
-    let mod_coh = assert false in
-    let t = Coh (mod_coh, coh, i1) in
+    let t = Coh (coh, i1) in
     if l = [] then t
     else
       let tgt_f_ty = Unchecked.rename_ty (F.ty ty_base l tgt) names in
@@ -267,12 +257,11 @@ module Make (Theory : Theory.S) = struct
       let ty = Unchecked.ty_apply_sub_ps ty i1 in
       let coh_src_sub_ps = F.whisk_sub_ps 0 t ty tgt_f tgt_f_ty in
       let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
-      Coh (mod_coh, comp, coh_src_sub_ps)
+      Coh (comp, coh_src_sub_ps)
 
   (* Construct target (src_f[i1]) * (t[i2]) *)
   let naturality_tgt coh ty src ty_base dim l i1 i2 names =
-    let mod_coh = assert false in
-    let t = Coh (mod_coh, coh, i2) in
+    let t = Coh (coh, i2) in
     if l = [] then t
     else
       let src_f_ty = Unchecked.rename_ty (F.ty ty_base l src) names in
@@ -282,7 +271,7 @@ module Make (Theory : Theory.S) = struct
       let ty = Unchecked.ty_apply_sub_ps ty i2 in
       let coh_tgt_sub_ps = F.whisk_sub_ps 0 src_f src_f_ty t ty in
       let comp = Suspension.coh (Some (dim - 1)) (Builtin.comp_n 2) in
-      Coh (mod_coh, comp, coh_tgt_sub_ps)
+      Coh (comp, coh_tgt_sub_ps)
 
   let biasor_sub_intch_src ps bdry_f i1 i2 d =
     let ps_red = Ps_reduction.reduce (d - 1) ps in
@@ -314,14 +303,12 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let d = Unchecked.dim_ps gamma in
     let src_ctx, src_incl, i1, i2, bdry_f, l_tgt, names = ctx_src gamma l in
     let coh_src = naturality_src coh coh_ty tgt ty_base d l_tgt i1 i2 names in
-    let coh_tgt =
-      Coh (mod_coh, coh_bridge, biasor_sub_intch_src gamma bdry_f i1 i2 d)
-    in
+    let coh_tgt = Coh (coh_bridge, biasor_sub_intch_src gamma bdry_f i1 i2 d) in
     let intch_coh =
       Coh.check_inv src_ctx coh_src coh_tgt ("intch_src", 0, [])
     in
     let _, ty, _ = Coh.forget intch_coh in
-    let intch = Coh (mod_coh, intch_coh, src_incl) in
+    let intch = Coh (intch_coh, src_incl) in
     let ty = Unchecked.ty_apply_sub_ps ty src_incl in
     (intch, ty)
 
@@ -331,14 +318,12 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let d = Unchecked.dim_ps gamma in
     let tgt_ctx, tgt_incl, i1, i2, bdry_f, l_src, names = ctx_tgt gamma l in
     let coh_tgt = naturality_tgt coh coh_ty src ty_base d l_src i1 i2 names in
-    let coh_src =
-      Coh (mod_coh, coh_bridge, biasor_sub_intch_tgt gamma bdry_f i1 i2 d)
-    in
+    let coh_src = Coh (coh_bridge, biasor_sub_intch_tgt gamma bdry_f i1 i2 d) in
     let intch_coh =
       Coh.check_inv tgt_ctx coh_src coh_tgt ("intch_tgt", 0, [])
     in
     let _, ty, _ = Coh.forget intch_coh in
-    let intch = Coh (mod_coh, intch_coh, tgt_incl) in
+    let intch = Coh (intch_coh, tgt_incl) in
     let ty = Unchecked.ty_apply_sub_ps ty tgt_incl in
     (intch, ty)
 
@@ -354,7 +339,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
       | (t, true) :: (w, false) :: red ->
           let ps_comp, s =
             match t with
-            | Coh (_, comp, s) ->
+            | Coh (comp, s) ->
                 let ps_comp, _, _ = Coh.forget comp in
                 (ps_comp, s)
             | Var v ->
@@ -430,7 +415,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let bridge = depth1_bridge_sub ps_inter l_inter d in
     let bridge = Unchecked.sub_ps_apply_sub bridge (F.sub names l_inter) in
     let coh_bridge_f = F.coh_depth0 coh_bridge l_bridge in
-    let middle = Coh (mod_coh, coh_bridge_f, bridge) in
+    let middle = Coh (coh_bridge_f, bridge) in
     let inner_tgt, final_tgt =
       match intch_tgt_ty with Arr (_, t, t') -> (t, t') | _ -> assert false
     in
@@ -448,7 +433,7 @@ https://q.uiver.app/#q=WzAsOCxbMSwwLCJcXHBhcnRpYWxcXEdhbW1hIl0sWzIsMSwiXFxvdmVyc
     let comp = Suspension.coh (Some d) (Builtin.comp_n 3) in
     let ctx = F.ctx (Unchecked.ps_to_ctx ps) l in
     let name = F.pp_data l pp_data in
-    check_term (Ctx.check ctx) ~name (Coh (mod_coh, comp, comp_sub_ps))
+    check_term (Ctx.check ctx) ~name (Coh (comp, comp_sub_ps))
 
   let init () = F.coh_depth1 := coh_depth1
 end
diff --git a/lib/meta_operations/cubical_composite.mli b/lib/meta_operations/cubical_composite.mli
index 8f3a2bab..fca5b8c2 100644
--- a/lib/meta_operations/cubical_composite.mli
+++ b/lib/meta_operations/cubical_composite.mli
@@ -1,3 +1,3 @@
-module Make (_ : Theory.S) : sig
+module Make (_ : KernelExt.S) : sig
   val init : unit -> unit
 end
diff --git a/lib/meta_operations/cylinders.ml b/lib/meta_operations/cylinders.ml
index b9c5bc10..d6fee92d 100644
--- a/lib/meta_operations/cylinders.ml
+++ b/lib/meta_operations/cylinders.ml
@@ -1,14 +1,13 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Construct = Construct.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
-  module Opposite = Opposite.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-
-  let mod_tm = assert false
+module Make (K : KernelExt.S) = struct
+  open K
+  module Construct = Construct.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
+  module Opposite = Opposite.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Builtin = Builtin.Make (K)
+
   let wcomp = Construct.wcomp
 
   (* Cylinder contexts *)
@@ -274,7 +273,7 @@ module Make (Theory : Theory.S) = struct
       in
       let c = Tm.ctx cubcomp in
       let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
-      let tm = App (mod_tm, cubcomp, sub) in
+      let tm = App (cubcomp, sub) in
       check_term (Ctx.check (ctx 2)) ~name:("cylcomp(2,1,2)", 0, []) tm
 
     let intch n =
@@ -337,7 +336,7 @@ module Make (Theory : Theory.S) = struct
                 (Suspension.sub (Some 1) (Cylinder.bdry_left (n - 1) (n - 2)))
             in
             check_term (Ctx.check ctx_comp) ~name:(name, 0, [])
-              (App (mod_tm, comp, sub))
+              (App (comp, sub))
           in
           let intch_lower, intch_upper = intch n in
           let scomp = (Tm.develop suspcomp, Tm.ty suspcomp) in
@@ -637,7 +636,7 @@ module Make (Theory : Theory.S) = struct
             let sub = List.map2 (fun (x, _) y -> (x, y)) c sub_ps in
             check_term (Ctx.check ctx)
               ~name:("builtin_cylstack", 0, [])
-              (App (mod_tm, tm, sub))
+              (App (tm, sub))
         | n ->
             let _, upper_incl = ctx (n - 1) in
             let lb = Cylinder.base_lower (n - 1) in
diff --git a/lib/meta_operations/cylinders.mli b/lib/meta_operations/cylinders.mli
index 5fa67970..77874228 100644
--- a/lib/meta_operations/cylinders.mli
+++ b/lib/meta_operations/cylinders.mli
@@ -1,5 +1,5 @@
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val compose : int -> int -> int -> Tm.t
   val stacking : int -> Tm.t
diff --git a/lib/meta_operations/eh.ml b/lib/meta_operations/eh.ml
index ce02d093..16e64e14 100644
--- a/lib/meta_operations/eh.ml
+++ b/lib/meta_operations/eh.ml
@@ -1,17 +1,15 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Construct = Construct.Make (Theory)
-  module Padding = Padding.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-  module Comp = Comp.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Opposite = Opposite.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
-  module Inverse = Inverse.Make (Theory)
-
-  let mod_coh = assert false
+module Make (K : KernelExt.S) = struct
+  open K
+  module Construct = Construct.Make (K)
+  module Padding = Padding.Make (K)
+  module Builtin = Builtin.Make (K)
+  module Comp = Comp.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Opposite = Opposite.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
+  module Inverse = Inverse.Make (K)
 
   module type EHArgsS = sig
     val n : int
@@ -488,7 +486,7 @@ module Make (Theory : Theory.S) = struct
       let runit = check_coh (Unchecked.disc 1) cohty ("_ehnat_step1", 0, []) in
       let d = Construct.dim constr in
       let sub = Construct.characteristic_sub_ps constr in
-      ( Coh (mod_coh, Suspension.coh (Some (d - 1)) runit, sub),
+      ( Coh (Suspension.coh (Some (d - 1)) runit, sub),
         Unchecked.ty_apply_sub_ps (Suspension.ty (Some (d - 1)) cohty) sub )
 
     let nat_factor eh_id_id ehargs =
diff --git a/lib/meta_operations/eh.mli b/lib/meta_operations/eh.mli
index 1115c917..14b18380 100644
--- a/lib/meta_operations/eh.mli
+++ b/lib/meta_operations/eh.mli
@@ -1,5 +1,5 @@
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val eh : int -> int -> int -> Tm.t
   val full_eh : int -> int -> int -> Tm.t
diff --git a/lib/meta_operations/functorialisation.ml b/lib/meta_operations/functorialisation.ml
index 59d1ab99..8df66a32 100644
--- a/lib/meta_operations/functorialisation.ml
+++ b/lib/meta_operations/functorialisation.ml
@@ -1,17 +1,14 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Comp = Comp.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
+  module Comp = Comp.Make (K)
+  module Suspension = Suspension.Make (K)
 
   exception FunctorialiseMeta
   exception NotClosed
   exception Unsupported
 
-  let mod_tm = assert false
-  let mod_coh = assert false
-
   let coh_depth1 =
     ref (fun _ -> Error.fatal "Uninitialised forward reference coh_depth1")
 
@@ -155,7 +152,7 @@ module Make (Theory : Theory.S) = struct
     let whisk = whisk n j k in
     let whisk_sub_ps = whisk_sub_ps k f fty g gty in
     let whisk_sub = Unchecked.sub_ps_to_sub whisk_sub_ps in
-    ( App (mod_tm, whisk, whisk_sub),
+    ( App (whisk, whisk_sub),
       Unchecked.ty_apply_sub_ps (Tm.ty whisk) whisk_sub_ps )
 
   (* Invariant maintained:
@@ -208,7 +205,7 @@ module Make (Theory : Theory.S) = struct
     let ps, _, _ = Coh.forget coh in
     Coh.apply
       (fun c -> ctx c l)
-      (fun t -> ty t l (Coh (mod_coh, coh, Unchecked.identity_ps ps)))
+      (fun t -> ty t l (Coh (coh, Unchecked.identity_ps ps)))
       (fun pp -> pp_data l pp)
       coh
 
@@ -229,10 +226,7 @@ module Make (Theory : Theory.S) = struct
     if l = [] then
       let ps, _, name = Coh.forget c in
       let id = Unchecked.identity_ps ps in
-      check_term
-        (Ctx.check (Unchecked.ps_to_ctx ps))
-        ~name
-        (Coh (mod_coh, c, id))
+      check_term (Ctx.check (Unchecked.ps_to_ctx ps)) ~name (Coh (c, id))
     else
       let cohf, names = coh c l in
       let next =
@@ -251,7 +245,7 @@ module Make (Theory : Theory.S) = struct
         [
           (Var (Var.Bridge v), expl); (Var (Var.Plus v), false); (Var v, false);
         ]
-    | Coh (_, c, s) ->
+    | Coh (c, s) ->
         let t' = Unchecked.tm_rename t (tgt_renaming l) in
         let sf = sub_ps s l in
         let ps, _, _ = Coh.forget c in
@@ -259,9 +253,9 @@ module Make (Theory : Theory.S) = struct
         let places = preimage psc s l in
         let cohf, _ = coh c places in
         let subf = Unchecked.list_to_sub (List.map fst sf) (Tm.ctx cohf) in
-        let tm = App (mod_tm, cohf, subf) in
+        let tm = App (cohf, subf) in
         [ (tm, expl); (t', false); (t, false) ]
-    | App (_, t, s) ->
+    | App (t, s) ->
         let total_t = Unchecked.tm_apply_sub (Tm.develop t) s in
         tm_one_step total_t l expl
     | Meta_tm _ -> raise FunctorialiseMeta
diff --git a/lib/meta_operations/functorialisation.mli b/lib/meta_operations/functorialisation.mli
index 987c6bbf..75a2808b 100644
--- a/lib/meta_operations/functorialisation.mli
+++ b/lib/meta_operations/functorialisation.mli
@@ -1,7 +1,7 @@
 open Common
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val coh_depth1 : (Coh.t -> Var.t list -> Tm.t) ref
   val preimage : ctx -> sub_ps -> Var.t list -> Var.t list
diff --git a/lib/meta_operations/inverse.ml b/lib/meta_operations/inverse.ml
index 18aac0e3..680afb10 100644
--- a/lib/meta_operations/inverse.ml
+++ b/lib/meta_operations/inverse.ml
@@ -1,14 +1,14 @@
 open Common
 open Std
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Opposite = Opposite.Make (Theory)
-  module Ps_reduction = Ps_reduction.Make (Theory)
-  module Telescope = Telescope.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
+  module Opposite = Opposite.Make (K)
+  module Ps_reduction = Ps_reduction.Make (K)
+  module Telescope = Telescope.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Builtin = Builtin.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
 
   exception NotInvertible of string
   exception CohNonInv
@@ -30,8 +30,8 @@ module Make (Theory : Theory.S) = struct
     match t with
     | Var x -> raise (NotInvertible (Var.to_string x))
     | Meta_tm _ -> t
-    | Coh (mod_coh, c, sub) -> (
-        try Coh (mod_coh, coh c, sub)
+    | Coh (c, sub) -> (
+        try Coh (coh c, sub)
         with CohNonInv ->
           let ps, _, _ = Coh.forget c in
           let d = Unchecked.dim_ps ps in
@@ -40,8 +40,8 @@ module Make (Theory : Theory.S) = struct
           let sub_inv = sub_inv sub pctx d in
           let equiv = Opposite.equiv_op_ps ps [ d ] in
           let coh = Opposite.coh c [ d ] in
-          Coh (mod_coh, coh, Unchecked.sub_ps_apply_sub equiv sub_inv))
-    | App (_, t, s) ->
+          Coh (coh, Unchecked.sub_ps_apply_sub equiv sub_inv))
+    | App (t, s) ->
         let t = Tm.develop t in
         let total_t = Unchecked.tm_apply_sub t s in
         compute_inverse total_t
@@ -67,8 +67,7 @@ module Make (Theory : Theory.S) = struct
     in
     let coh_vertically_grouped = Ps_reduction.coh coh_unbiased in
     let reduce = Ps_reduction.reduction_sub ps in
-    let mod_coh = assert false in
-    let t_vertically_grouped = Coh (mod_coh, coh_vertically_grouped, reduce) in
+    let t_vertically_grouped = Coh (coh_vertically_grouped, reduce) in
     Coh.check_inv ps t t_vertically_grouped ("vertical_grouping", 0, [])
 
   type lin_comp = { arity : int; dim : int; sub_ps : sub_ps }
@@ -76,7 +75,7 @@ module Make (Theory : Theory.S) = struct
   let tm_to_lin_comp t =
     let ps, sub_ps =
       match t with
-      | Coh (_, c, s) ->
+      | Coh (c, s) ->
           let ps, _, _ = Coh.forget c in
           (ps, s)
       | _ -> Error.fatal "term must be a linear composite"
@@ -109,14 +108,11 @@ module Make (Theory : Theory.S) = struct
         (sub_to_telescope (2 * k) lc.sub_ps [])
         (Suspension.ctx (Some (lc.dim - 1)) ctel)
     in
-    let mod_tm = assert false in
-    App (mod_tm, Suspension.checked_tm (Some (lc.dim - 1)) tel, stel)
+    App (Suspension.checked_tm (Some (lc.dim - 1)) tel, stel)
 
   and cancel_all_linear_comp t =
-    let mod_coh, c, sub =
-      match t with
-      | Coh (mod_coh, c, sub) -> (mod_coh, c, sub)
-      | _ -> Error.fatal ""
+    let c, sub =
+      match t with Coh (c, sub) -> (c, sub) | _ -> Error.fatal ""
     in
     let ps, _, _ = Coh.forget c in
     let d = Unchecked.dim_ps ps in
@@ -130,7 +126,7 @@ module Make (Theory : Theory.S) = struct
             let id =
               Suspension.coh (Some (Unchecked.dim_ty ty_base)) (Builtin.id ())
             in
-            Coh (mod_coh, id, (src_t, true) :: sub_base)
+            Coh (id, (src_t, true) :: sub_base)
           in
           (t_wit, true) :: (id_src_t, false) :: (t, false) :: (src_t, false)
           :: (src_t, false) :: sub
@@ -153,14 +149,14 @@ module Make (Theory : Theory.S) = struct
           in
           Unchecked.wedge_sub_ps_bp lsubs
     in
-    Coh (mod_coh, Functorialisation.coh_all_depth0 c, compute_sub 0 ps sub Obj)
+    Coh (Functorialisation.coh_all_depth0 c, compute_sub 0 ps sub Obj)
 
   and compute_witness t =
     match t with
     | Var x -> raise (NotInvertible (Var.to_string x))
     | Meta_tm _ ->
         raise (NotInvertible "Meta_variable not allowed in witness generation")
-    | Coh (_, c, s) ->
+    | Coh (c, s) ->
         let ps, ty, pp_data = Coh.forget c in
         let d = Coh.dim c in
         let sub_base, u, v =
@@ -171,48 +167,45 @@ module Make (Theory : Theory.S) = struct
         if Coh.is_inv c then
           compute_witness_coh_inv c s ~ps ~d ~pp_data ~sub_base ~u ~v
         else compute_witness_comp c s ~ps ~d ~sub_base ~u ~v
-    | App (_, t, s) ->
+    | App (t, s) ->
         let t = Tm.develop t in
         let total_t = Unchecked.tm_apply_sub t s in
         compute_witness total_t
 
   and compute_witness_coh_inv c s ~ps ~pp_data ~d ~sub_base ~u ~v =
     let name, susp, func = pp_data in
-    let mod_coh = assert false in
     let src_wit =
       let id_ps = Unchecked.identity_ps ps in
       let c_inv = coh c in
       let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
       let c_c_inv =
-        (Coh (mod_coh, c_inv, id_ps), true)
+        (Coh (c_inv, id_ps), true)
         :: (u, false)
-        :: (Coh (mod_coh, c, id_ps), true)
+        :: (Coh (c, id_ps), true)
         :: (v, true) :: (u, true) :: sub_base
       in
-      Coh (mod_coh, comp, c_c_inv)
+      Coh (comp, c_c_inv)
     in
     let tgt_wit =
       let id = Suspension.coh (Some (d - 1)) (Builtin.id ()) in
       let sub_id_u = (u, true) :: sub_base in
-      Coh (mod_coh, id, sub_id_u)
+      Coh (id, sub_id_u)
     in
     let c_wit = Coh.check_inv ps src_wit tgt_wit (name ^ "_Unit", susp, func) in
-    Coh (mod_coh, c_wit, s)
+    Coh (c_wit, s)
 
   and compute_witness_comp c s ~ps ~d ~sub_base ~u ~v =
-    let mod_coh = assert false in
     let ps_doubled, inl, inr = Unchecked.ps_compose (d - 1) ps ps in
     let t =
-      let tm1 = Coh (mod_coh, c, inl) in
+      let tm1 = Coh (c, inl) in
       let c_op = Opposite.coh c [ d ] in
-      let tm2 = Coh (mod_coh, c_op, inr) in
+      let tm2 = Coh (c_op, inr) in
       let sub_inr = Unchecked.sub_ps_to_sub inr in
       let sub_inl = Unchecked.sub_ps_to_sub inl in
       let w = Unchecked.tm_apply_sub (Coh.tgt c_op) sub_inr in
       let comp = Suspension.coh (Some (d - 1)) (Builtin.comp_n 2) in
       Coh
-        ( mod_coh,
-          comp,
+        ( comp,
           (tm2, true) :: (w, false) :: (tm1, true)
           :: Unchecked.sub_ps_apply_sub
                ((v, false) :: (u, false) :: sub_base)
@@ -234,7 +227,7 @@ module Make (Theory : Theory.S) = struct
       in
       let ssinv = Unchecked.pullback_up (d - 1) ps ps s sinv in
       let subsinv = Unchecked.sub_ps_to_sub ssinv in
-      ( Coh (mod_coh, coh, ssinv),
+      ( Coh (coh, ssinv),
         Unchecked.tm_apply_sub src subsinv,
         Unchecked.tm_apply_sub tgt subsinv )
     in
@@ -244,7 +237,7 @@ module Make (Theory : Theory.S) = struct
       let src, tgt = (Coh.src coh, Coh.tgt coh) in
       let s = Unchecked.sub_ps_apply_sub (Unchecked.ps_src ps) sub in
       let sub = Unchecked.sub_ps_to_sub s in
-      ( Coh (mod_coh, coh, s),
+      ( Coh (coh, s),
         Unchecked.tm_apply_sub src sub,
         Unchecked.tm_apply_sub tgt sub )
     in
@@ -253,7 +246,7 @@ module Make (Theory : Theory.S) = struct
       :: (m1, true) :: (tgt_m1, false) :: (src_m1, false)
       :: Unchecked.sub_ps_apply_sub ((u, false) :: (u, false) :: sub_base) sub
     in
-    Coh (mod_coh, Suspension.coh (Some d) (Builtin.comp_n 3), sub_total)
+    Coh (Suspension.coh (Some d) (Builtin.comp_n 3), sub_total)
 
   let compute_witness t =
     try
diff --git a/lib/meta_operations/inverse.mli b/lib/meta_operations/inverse.mli
index 221f29c6..85744e75 100644
--- a/lib/meta_operations/inverse.mli
+++ b/lib/meta_operations/inverse.mli
@@ -1,5 +1,5 @@
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val ty : ty -> ty
   val compute_inverse : tm -> tm
diff --git a/lib/meta_operations/opposite.ml b/lib/meta_operations/opposite.ml
index 21e2e10e..9d4fb6a0 100644
--- a/lib/meta_operations/opposite.ml
+++ b/lib/meta_operations/opposite.ml
@@ -5,84 +5,25 @@ let rec op_data_to_string = function
   | [ i ] -> Printf.sprintf "%i" i
   | i :: l -> Printf.sprintf "%i,%s" i (op_data_to_string l)
 
-let ps ps op_data =
-  let rec level i ps =
-    match ps with
-    | Br [] -> Br []
-    | Br l when List.mem (i + 1) op_data ->
-        let l = List.map (level (i + 1)) l in
-        Br (List.rev l)
-    | Br l -> Br (List.map (level (i + 1)) l)
-  in
-  level 0 ps
+module Make (K : KernelExt.S) = struct
+  open K
 
-let op_pp_data pp_data op_data =
-  let name = Printing.full_name pp_data in
-  let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
-  (name, 0, [])
-
-let rec ty typ op_data =
-  let d = Unchecked.dim_ty typ in
-  match typ with
-  | Obj -> Obj
-  | Arr (a, t, u) ->
-      let a = ty a op_data in
-      let t = tm t op_data in
-      let u = tm u op_data in
-      if List.mem d op_data then Arr (a, u, t) else Arr (a, t, u)
-  | Meta_ty m -> Meta_ty m
-
-and tm t op_data =
-  match t with
-  | Var x -> Var x
-  | Coh (mod_coh, c, s) ->
-      let p, _, _ = Coh.forget c in
-      let equiv = equiv_op_ps p op_data in
-      let c = coh c op_data equiv in
-      let op_s = sub (Unchecked.sub_ps_to_sub s) op_data in
-      let s' = Unchecked.sub_ps_apply_sub equiv op_s in
-      Coh (mod_coh, c, s')
-  | App (mod_tm, t, s) ->
-      let op_t, _ =
-        Tm.apply
-          (fun c -> ctx c op_data)
-          (fun t -> tm t op_data)
-          (fun pp_data -> op_pp_data pp_data op_data)
-          t
-      in
-      let op_s = sub s op_data in
-      let op_s = Unchecked.(sub_ps_to_sub (sub_to_sub_ps op_s)) in
-      App (mod_tm, op_t, op_s)
-  | Meta_tm m -> Meta_tm m
-
-and sub s op_data =
-  match s with
-  | [] -> []
-  | (x, (t, e)) :: s -> (x, (tm t op_data, e)) :: sub s op_data
-
-and coh c op_data equiv =
-  Coh.apply_ps
-    (fun p -> ps p op_data)
-    (fun t ->
-      Unchecked.ty_sub_preimage (ty t op_data) (Unchecked.sub_ps_to_sub equiv))
-    (fun pp -> op_pp_data pp op_data)
-    c
-
-and ctx c op_data =
-  match c with
-  | [] -> []
-  | (x, (t, e)) :: c ->
-      let t = ty t op_data in
-      let c = ctx c op_data in
-      (x, (t, e)) :: c
+  let ps ps op_data =
+    let rec level i ps =
+      match ps with
+      | Br [] -> Br []
+      | Br l when List.mem (i + 1) op_data ->
+          let l = List.map (level (i + 1)) l in
+          Br (List.rev l)
+      | Br l -> Br (List.map (level (i + 1)) l)
+    in
+    level 0 ps
 
-let tm t op_data =
-  Io.info ~v:3 (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
-  let t = tm t op_data in
-  Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
-  t
+  let op_pp_data pp_data op_data =
+    let name = Printing.full_name pp_data in
+    let name = Printf.sprintf "%s_op{%s}" name (op_data_to_string op_data) in
+    (name, 0, [])
 
-module Make (K : KernelS) = struct
   let equiv_op_ps ps op_data =
     let rec level i ps =
       match ps with
@@ -95,6 +36,68 @@ module Make (K : KernelS) = struct
     in
     level 0 ps
 
+  let rec ty typ op_data =
+    let d = Unchecked.dim_ty typ in
+    match typ with
+    | Obj -> Obj
+    | Arr (a, t, u) ->
+        let a = ty a op_data in
+        let t = tm t op_data in
+        let u = tm u op_data in
+        if List.mem d op_data then Arr (a, u, t) else Arr (a, t, u)
+    | Meta_ty m -> Meta_ty m
+
+  and tm t op_data =
+    match t with
+    | Var x -> Var x
+    | Coh (c, s) ->
+        let p, _, _ = Coh.forget c in
+        let equiv = equiv_op_ps p op_data in
+        let c = coh c op_data equiv in
+        let op_s = sub (Unchecked.sub_ps_to_sub s) op_data in
+        let s' = Unchecked.sub_ps_apply_sub equiv op_s in
+        Coh (c, s')
+    | App (t, s) ->
+        let op_t, _ =
+          Tm.apply
+            (fun c -> ctx c op_data)
+            (fun t -> tm t op_data)
+            (fun pp_data -> op_pp_data pp_data op_data)
+            t
+        in
+        let op_s = sub s op_data in
+        let op_s = Unchecked.(sub_ps_to_sub (sub_to_sub_ps op_s)) in
+        App (op_t, op_s)
+    | Meta_tm m -> Meta_tm m
+
+  and sub s op_data =
+    match s with
+    | [] -> []
+    | (x, (t, e)) :: s -> (x, (tm t op_data, e)) :: sub s op_data
+
+  and coh c op_data equiv =
+    Coh.apply_ps
+      (fun p -> ps p op_data)
+      (fun t ->
+        Unchecked.ty_sub_preimage (ty t op_data) (Unchecked.sub_ps_to_sub equiv))
+      (fun pp -> op_pp_data pp op_data)
+      c
+
+  and ctx c op_data =
+    match c with
+    | [] -> []
+    | (x, (t, e)) :: c ->
+        let t = ty t op_data in
+        let c = ctx c op_data in
+        (x, (t, e)) :: c
+
+  let tm t op_data =
+    Io.info ~v:3
+      (lazy ("computing opposite of term " ^ Printing.tm_to_string t));
+    let t = tm t op_data in
+    Io.info ~v:4 (lazy ("opposite computed: " ^ Printing.tm_to_string t));
+    t
+
   let coh c op_data =
     let ps, _, _ = Coh.forget c in
     let equiv = equiv_op_ps ps op_data in
diff --git a/lib/meta_operations/opposite.mli b/lib/meta_operations/opposite.mli
index a1db7f1f..987f6cf1 100644
--- a/lib/meta_operations/opposite.mli
+++ b/lib/meta_operations/opposite.mli
@@ -1,14 +1,14 @@
 open Common
 
 val op_data_to_string : op_data -> string
-val tm : ('a, 'b) tm -> op_data -> ('a, 'b) tm
-val sub : ('a, 'b) sub -> op_data -> ('a, 'b) sub
-val ty : ('a, 'b) ty -> op_data -> ('a, 'b) ty
-val ctx : ('a, 'b) ctx -> op_data -> ('a, 'b) ctx
 
-module Make (K : KernelS) : sig
+module Make (K : KernelExt.S) : sig
   open K
 
+  val tm : tm -> op_data -> tm
+  val sub : sub -> op_data -> sub
+  val ty : ty -> op_data -> ty
+  val ctx : ctx -> op_data -> ctx
   val coh : Coh.t -> op_data -> Coh.t
   val checked_tm : Tm.t -> op_data -> Tm.t
   val equiv_op_ps : ps -> op_data -> sub_ps
diff --git a/lib/meta_operations/padding.ml b/lib/meta_operations/padding.ml
index 24a0fcc7..825e21b7 100644
--- a/lib/meta_operations/padding.ml
+++ b/lib/meta_operations/padding.ml
@@ -1,11 +1,11 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Construct = Construct.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
+  module Construct = Construct.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Builtin = Builtin.Make (K)
 
   module type StringS = sig
     val value : string
@@ -349,7 +349,7 @@ module Make (Theory : Theory.S) = struct
 
     let repad_one_step p_0 p_1 f q_0 q_1 g (previous : Tm.t) iota_minus
         iota_plus v sub =
-      match previous.ty.e with
+      match Ty.expr (Tm.typ previous) with
       | Obj -> assert false
       | Arr (_, padding_0, padding_1) ->
           hexcomp (Tm.constr p_0) (Tm.constr p_1)
diff --git a/lib/meta_operations/padding.mli b/lib/meta_operations/padding.mli
index ae6be545..4aa31f15 100644
--- a/lib/meta_operations/padding.mli
+++ b/lib/meta_operations/padding.mli
@@ -1,7 +1,7 @@
 open Common
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   module type StringS = sig
     val value : string
diff --git a/lib/meta_operations/ps_reduction.ml b/lib/meta_operations/ps_reduction.ml
index a1f0b9aa..c28734f6 100644
--- a/lib/meta_operations/ps_reduction.ml
+++ b/lib/meta_operations/ps_reduction.ml
@@ -1,8 +1,8 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
+  module Builtin = Builtin.Make (K)
 
   let tdb i = Var (Var.Db i)
 
@@ -13,7 +13,6 @@ module Make (Theory : Theory.S) = struct
     | i, Br l -> Br (List.map (reduce (i - 1)) l)
 
   let reduction_sub ps =
-    let mod_coh = assert false in
     let rec aux i ps =
       match (i, ps) with
       | _, Br [] -> [ (tdb 0, true) ]
@@ -21,8 +20,7 @@ module Make (Theory : Theory.S) = struct
       | 0, Br l ->
           let k = List.length l in
           [
-            ( Coh (mod_coh, Builtin.comp_n k, Unchecked.(identity_ps (Br l))),
-              true );
+            (Coh (Builtin.comp_n k, Unchecked.(identity_ps (Br l))), true);
             (tdb ((2 * k) - 1), false);
             (tdb 0, false);
           ]
diff --git a/lib/meta_operations/ps_reduction.mli b/lib/meta_operations/ps_reduction.mli
index bf1fcb69..1b3d2e25 100644
--- a/lib/meta_operations/ps_reduction.mli
+++ b/lib/meta_operations/ps_reduction.mli
@@ -1,7 +1,7 @@
 open Common
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val reduce : int -> ps -> ps
   val reduction_sub : ps -> sub_ps
diff --git a/lib/meta_operations/suspension.ml b/lib/meta_operations/suspension.ml
index c545966a..f9fe5494 100644
--- a/lib/meta_operations/suspension.ml
+++ b/lib/meta_operations/suspension.ml
@@ -1,5 +1,5 @@
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
+module Make (K : KernelExt.S) = struct
+  open K
 
   let rec iter_n_times n f base =
     if n <= 0 then base else f (iter_n_times (n - 1) f base)
diff --git a/lib/meta_operations/suspension.mli b/lib/meta_operations/suspension.mli
index d08d71bd..463d06ef 100644
--- a/lib/meta_operations/suspension.mli
+++ b/lib/meta_operations/suspension.mli
@@ -1,7 +1,7 @@
 open Common
 
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val ps : int option -> ps -> ps
   val ty : int option -> ty -> ty
diff --git a/lib/meta_operations/telescope.ml b/lib/meta_operations/telescope.ml
index 68a68cc9..0a2a4f1b 100644
--- a/lib/meta_operations/telescope.ml
+++ b/lib/meta_operations/telescope.ml
@@ -1,20 +1,16 @@
 open Common
 
-module Make (Theory : Theory.S) = struct
-  open Kernel.Make (Theory)
-  module Builtin = Builtin.Make (Theory)
-  module Suspension = Suspension.Make (Theory)
-  module Functorialisation = Functorialisation.Make (Theory)
-
-  let mod_coh = assert false
+module Make (K : KernelExt.S) = struct
+  open K
+  module Builtin = Builtin.Make (K)
+  module Suspension = Suspension.Make (K)
+  module Functorialisation = Functorialisation.Make (K)
 
   (* returns the associator pairing up the middle two cells of a composite of
     (2*k) 1-cells. The argument is the integer k *)
   let middle_associator k =
     let ps = Builtin.ps_comp (2 * k) in
-    let src =
-      Coh (mod_coh, Builtin.comp_n (2 * k), Unchecked.(identity_ps ps))
-    in
+    let src = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
     let tgt =
       let sub_assoc_middle =
         let rec compute_sub i =
@@ -34,7 +30,7 @@ module Make (Theory : Theory.S) = struct
                   (Var (Db ((2 * k) - 3)), false);
                 ]
               in
-              let comp = Coh (mod_coh, Builtin.comp_n 2, sub_comp) in
+              let comp = Coh (Builtin.comp_n 2, sub_comp) in
               (comp, true)
               :: (Var (Db ((2 * k) + 1)), false)
               :: compute_sub (k - 1)
@@ -45,7 +41,7 @@ module Make (Theory : Theory.S) = struct
         in
         compute_sub ((2 * k) - 1)
       in
-      Coh (mod_coh, Builtin.comp_n ((2 * k) - 1), sub_assoc_middle)
+      Coh (Builtin.comp_n ((2 * k) - 1), sub_assoc_middle)
     in
     Coh.check_inv ps src tgt ("focus", 0, [])
 
@@ -64,7 +60,7 @@ module Make (Theory : Theory.S) = struct
               :: compute_sub (i - 1)
           | i when i = k + 1 ->
               let id =
-                Coh (mod_coh, Builtin.id (), [ (Var (Db ((2 * k) - 1)), false) ])
+                Coh (Builtin.id (), [ (Var (Db ((2 * k) - 1)), false) ])
               in
               (id, true) :: (Var (Db ((2 * k) - 1)), false) :: compute_sub k
           | i ->
@@ -74,11 +70,9 @@ module Make (Theory : Theory.S) = struct
         in
         compute_sub ((2 * k) + 1)
       in
-      Coh (mod_coh, Builtin.comp_n ((2 * k) + 1), sub_id_middle)
-    in
-    let tgt =
-      Coh (mod_coh, Builtin.comp_n (2 * k), Unchecked.(identity_ps ps))
+      Coh (Builtin.comp_n ((2 * k) + 1), sub_id_middle)
     in
+    let tgt = Coh (Builtin.comp_n (2 * k), Unchecked.(identity_ps ps)) in
     Coh.check_inv ps src tgt ("unit", 0, [])
 
   (* returns the whiskering rewriting the middle term of a composite of (2*k+1)
@@ -100,8 +94,7 @@ module Make (Theory : Theory.S) = struct
     Arr
       ( Arr (Obj, Var (obj (k - 1)), Var (obj (k - 1))),
         Coh
-          ( mod_coh,
-            Builtin.comp_n 2,
+          ( Builtin.comp_n 2,
             [
               (Var (cell_backward k), true);
               (Var (obj (k - 1)), false);
@@ -109,7 +102,7 @@ module Make (Theory : Theory.S) = struct
               (Var (obj k), false);
               (Var (obj (k - 1)), false);
             ] ),
-        Coh (mod_coh, Builtin.id (), [ (Var (obj (k - 1)), true) ]) )
+        Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]) )
 
   let rec ctx k =
     match k with
@@ -133,8 +126,7 @@ module Make (Theory : Theory.S) = struct
         if whisk then
           let src_max_var =
             Coh
-              ( mod_coh,
-                Builtin.comp_n 2,
+              ( Builtin.comp_n 2,
                 [
                   (Var (cell_backward k), true);
                   (Var (obj (k - 1)), false);
@@ -147,8 +139,7 @@ module Make (Theory : Theory.S) = struct
             List.append left
               [
                 (Var (cell_max k), true);
-                ( Coh (mod_coh, Builtin.id (), [ (Var (obj (k - 1)), true) ]),
-                  false );
+                (Coh (Builtin.id (), [ (Var (obj (k - 1)), true) ]), false);
                 (src_max_var, false);
                 (Var (obj (k - 1)), false);
               ] )
@@ -172,16 +163,13 @@ module Make (Theory : Theory.S) = struct
           let sub = Unchecked.sub_ps_to_sub sub_ps in
           let t = Unchecked.tm_apply_sub t sub in
           let u = Unchecked.tm_apply_sub u sub in
-          (Coh (mod_coh, coh, sub_ps), t, u)
+          (Coh (coh, sub_ps), t, u)
         in
         let m3, src_m3, tgt_m3 =
           tm_src_tgt (middle_unitor (k - 1)) (sub_ps_telescope_bdry (k - 1))
         in
         let m2 =
-          Coh
-            ( mod_coh,
-              middle_rewrite (k - 1),
-              sub_ps_telescope_bdry ~whisk:true k )
+          Coh (middle_rewrite (k - 1), sub_ps_telescope_bdry ~whisk:true k)
         in
         let m1, src_m1, tgt_m1 =
           tm_src_tgt (middle_associator k) (sub_ps_telescope_bdry k)
@@ -189,7 +177,7 @@ module Make (Theory : Theory.S) = struct
         let sub_telescope =
           [
             (telescope (k - 1), true);
-            (Coh (mod_coh, Builtin.id (), [ (tdb 0, true) ]), false);
+            (Coh (Builtin.id (), [ (tdb 0, true) ]), false);
             (m3, true);
             (tgt_m3, false);
             (m2, true);
@@ -201,7 +189,7 @@ module Make (Theory : Theory.S) = struct
             (tdb 0, false);
           ]
         in
-        Coh (mod_coh, comp, sub_telescope)
+        Coh (comp, sub_telescope)
 
   let checked k =
     let name = "builtin_telescope" ^ string_of_int k in
diff --git a/lib/meta_operations/telescope.mli b/lib/meta_operations/telescope.mli
index 835cebf0..461ea679 100644
--- a/lib/meta_operations/telescope.mli
+++ b/lib/meta_operations/telescope.mli
@@ -1,5 +1,5 @@
-module Make (Theory : Theory.S) : sig
-  open Kernel.Make(Theory)
+module Make (K : KernelExt.S) : sig
+  open K
 
   val ctx : int -> ctx
   val telescope : int -> tm
diff --git a/rocq_plugin/src/export.ml b/rocq_plugin/src/export.ml
index 3e6167bf..479f9e4d 100644
--- a/rocq_plugin/src/export.ml
+++ b/rocq_plugin/src/export.ml
@@ -43,14 +43,10 @@ let clean_name s =
       | c -> c)
     s
 
-module type TranslateS = sig
-  val catt_tm : string -> unit
-end
-
 let tbl : (string, string) Hashtbl.t = Hashtbl.create 97
 
-module Translate (Environment : Environments.S) : TranslateS = struct
-  open Environment
+module Translate (K : KernelExt.S) = struct
+  open K
 
   let retrieve_lambda catt_name sigma =
     let build_econstr name =
@@ -158,13 +154,13 @@ module Translate (Environment : Environments.S) : TranslateS = struct
   and tm_to_econstr env sigma obj_type eq_type refl ctx tm =
     match tm with
     | Var x -> (env, sigma, EConstr.mkRel (find_db ctx x))
-    | Coh (_, c, s) ->
+    | Coh (c, s) ->
         let env, sigma, c = coh_to_lambda env sigma obj_type eq_type refl c in
         let env, sigma, s =
           sub_ps_to_econstr_array env sigma obj_type eq_type refl ctx s
         in
         (env, sigma, EConstr.mkApp (c, s))
-    | App (_, tm, s) ->
+    | App (tm, s) ->
         let env, sigma, tm = tm_to_lambda env sigma obj_type eq_type refl tm in
         let env, sigma, s =
           sub_to_econstr_array env sigma obj_type eq_type refl ctx s
@@ -216,7 +212,7 @@ module Translate (Environment : Environments.S) : TranslateS = struct
   and coh_to_lambda env sigma obj_type eq_type refl coh =
     let ps, ty, name = Coh.forget coh in
     let catt_name = "coh_" ^ clean_name (Printing.full_name name) in
-    let value = Environment.Coh coh in
+    let value = VCoh coh in
     match retrieve_lambda catt_name sigma with
     | Some res -> res
     | None ->
@@ -275,7 +271,7 @@ module Translate (Environment : Environments.S) : TranslateS = struct
       | None -> anon ()
     in
     let catt_name = "tm_" ^ name in
-    let value = Environment.Tm tm in
+    let value = VTm tm in
     match retrieve_lambda catt_name sigma with
     | Some res -> res
     | None ->
@@ -300,21 +296,20 @@ module Translate (Environment : Environments.S) : TranslateS = struct
     let sigma, eq_type = c_Q env sigma in
     let sigma, refl = c_R env sigma in
     ignore (coh_to_lambda env sigma obj_type eq_type refl coh)
-
-  let catt_tm tm_name =
-    let env = Global.env () in
-    let sigma = Evd.from_env env in
-    match Environment.val_var (Var.Name tm_name) with
-    | Coh c -> coh env sigma c
-    | Tm t -> tm env sigma t
 end
 
 let catt_tm file tm_names =
   run_catt_on_file file;
-  let env =
-    List.hd (Environments.find_environment (Var.Name (List.hd tm_names)))
+  let register_tm tm_name =
+    match Environments.find (Var.Name tm_name) with
+    | [ Val ((module K), value) ] -> (
+        let module Translate = Translate (K) in
+        let env = Global.env () in
+        let sigma = Evd.from_env env in
+        match value with
+        | VCoh c -> Translate.coh env sigma c
+        | VTm t -> Translate.tm env sigma t)
+    | [] -> assert false
+    | _ -> Error.fatal "rocq export does not support multiple theories"
   in
-  let module Env = (val env : Environments.S) in
-  let module Translate = Translate (Env) in
-  let register_tm tm_name = Translate.catt_tm tm_name in
   List.iter register_tm tm_names

From 0f4de54c32f7d398f633940ef9d02efaa3445b4c Mon Sep 17 00:00:00 2001
From: Thibaut Benjamin <thibaut.benjamin@gmail.com>
Date: Wed, 3 Dec 2025 13:13:00 +0100
Subject: [PATCH 30/30] [bugfix] fix test for the rocq plugin

---
 lib/internals/kernel.mli    | 2 ++
 rocq_plugin/theories/Test.v | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/internals/kernel.mli b/lib/internals/kernel.mli
index de445772..bea5da7e 100644
--- a/lib/internals/kernel.mli
+++ b/lib/internals/kernel.mli
@@ -1,3 +1,5 @@
 open Common
 
+(* Like a functor but returns a first class module, as it enforces the invariant
+that there is at most one kernel for a given theory. *)
 val make : theory -> (module KernelExt.S)
diff --git a/rocq_plugin/theories/Test.v b/rocq_plugin/theories/Test.v
index 46f7c35c..29c7719d 100644
--- a/rocq_plugin/theories/Test.v
+++ b/rocq_plugin/theories/Test.v
@@ -3,7 +3,7 @@ From Catt Require Import Loader.
 Catt "identity" "composite" "ternarycomposite" "whiskr"  "hcomp" "vcomp"  "exchange" "assoc" "assocI" "assocU" "complex" From File "../../test.t/features/coq_plugin.catt".
 
 Print catt_coh_identity.
-Print catt_coh_composite.
+Print catt_coh_builtin_comp2.
 Print catt_coh_ternarycomposite.
 Print catt_coh_whiskr.