show typechecked source code in .out files & fix local function handling (again)

1 files changed, 2139 insertions, 741 deletions

diff --git a/testdata/Builtins.out b/testdata/Builtins.out
index 2c4b1a46..e5a33d12 100644
--- a/testdata/Builtins.out
+++ b/testdata/Builtins.out
@@ -10,7 +10,7 @@ data VecS (_ :: Type) :: Nat -> Type where
 mapVec :: forall (a :: _) (b :: _) (c :: _) . (a -> b) -> VecS a c -> VecS b c
 mapVec
   = \(a :: _) (b :: _) -> case'VecS
-    (\_ _ -> _)
+    (\(_ :: _) (_ :: _) -> _)
     (\(c :: _) (d :: _) -> _rhs (V2 (a c) (a d)))
     (\(e :: _) (f :: _) (g :: _) -> _rhs (V3 (a e) (a f) (a g)))
     (\(h :: _) (i :: _) (j :: _) (k :: _) -> _rhs (V4 (a h) (a i) (a j) (a k)))
@@ -22,10 +22,10 @@ mapVec
 'VecScalar :: Nat -> Type -> Type
 'VecScalar
   = \(a :: _) (b :: _) -> case'Nat
-    (\_ -> _)
+    (\(_ :: _) -> _)
     undefined
     (\(c :: _) -> case'Nat
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs b)
       (\(d :: _) -> _rhs ('Vec (Succ (Succ d)) b))
       c)
@@ -72,31 +72,35 @@ data Mat :: Nat -> Nat -> Type -> Type where
 'MatVecScalarElem :: Type -> Type
 'MatVecScalarElem
   = \(a :: _) -> match'Float
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs 'Float)
     a
     (match'Bool
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs 'Bool)
       a
       (match'Int
-        (\_ -> _)
+        (\(_ :: _) -> _)
         (_rhs 'Int)
         a
         (match'VecS
-          (\_ -> _)
-          (\(b :: _) _ -> _rhs b)
+          (\(_ :: _) -> _)
+          (\(b :: _) (_ :: _) -> _rhs b)
           a
-          (match'Mat (\_ -> _) (\_ _ (c :: _) -> _rhs c) a undefined))))
+          (match'Mat
+            (\(_ :: _) -> _)
+            (\(_ :: _) (_ :: _) (c :: _) -> _rhs c)
+            a
+            undefined))))
 
 'Signed :: Type -> Constraint
 'Signed
   = \(a :: _) -> match'Int
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs 'CUnit)
     a
     (match'Float
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs 'CUnit)
       a
       (_rhs ('CEmpty "no instance of 'Signed on ???")))
@@ -104,37 +108,37 @@ data Mat :: Nat -> Nat -> Type -> Type where
 'Component :: Type -> Constraint
 'Component
   = \(a :: _) -> match'Int
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs 'CUnit)
     a
     (match'Word
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs 'CUnit)
       a
       (match'Float
-        (\_ -> _)
+        (\(_ :: _) -> _)
         (_rhs 'CUnit)
         a
         (match'VecS
-          (\_ -> _)
+          (\(_ :: _) -> _)
           (\(b :: _) (c :: _) -> match'Float
-            (\_ -> _)
+            (\(_ :: _) -> _)
             (case'Nat
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (_rhs ('CEmpty "no instance of 'Component on ???"))
               (\(d :: _) -> case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs ('CEmpty "no instance of 'Component on ???"))
                 (\(e :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs 'CUnit)
                   (\(f :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs 'CUnit)
                     (\(g :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs 'CUnit)
-                      (\_ -> _rhs ('CEmpty "no instance of 'Component on ???"))
+                      (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Component on ???"))
                       g)
                     f)
                   e)
@@ -142,23 +146,23 @@ data Mat :: Nat -> Nat -> Type -> Type where
               c)
             b
             (match'Bool
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs ('CEmpty "no instance of 'Component on ???"))
                 (\(h :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs ('CEmpty "no instance of 'Component on ???"))
                   (\(i :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs 'CUnit)
                     (\(j :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs 'CUnit)
                       (\(k :: _) -> case'Nat
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (_rhs 'CUnit)
-                        (\_ -> _rhs ('CEmpty "no instance of 'Component on ???"))
+                        (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Component on ???"))
                         k)
                       j)
                     i)
@@ -168,45 +172,45 @@ data Mat :: Nat -> Nat -> Type -> Type where
               (_rhs ('CEmpty "no instance of 'Component on ???"))))
           a
           (match'Bool
-            (\_ -> _)
+            (\(_ :: _) -> _)
             (_rhs 'CUnit)
             a
             (_rhs ('CEmpty "no instance of 'Component on ???"))))))
 
 zero :: forall a . Component a => a
 zero
-  = \ @a @_ -> match'Int
-    (\_ -> _)
+  = \ @a @(_ :: _) -> match'Int
+    (\(_ :: _) -> _)
     (_rhs let b = _rhs (fromInt 0 :: Int) in b)
     a
     (match'Word
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs let c = _rhs (fromInt 0 :: Word) in c)
       a
       (match'Float
-        (\_ -> _)
+        (\(_ :: _) -> _)
         (_rhs let d = _rhs 0.0 in d)
         a
         (match'VecS
-          (\_ -> _)
+          (\(_ :: _) -> _)
           (\(e :: _) (f :: _) -> match'Float
-            (\_ -> _)
+            (\(_ :: _) -> _)
             (case'Nat
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (_rhs undefined)
               (\(g :: _) -> case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs undefined)
                 (\(h :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs let i = _rhs (V2 0.0 0.0) in i)
                   (\(j :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs let k = _rhs (V3 0.0 0.0 0.0) in k)
                     (\(l :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs let m = _rhs (V4 0.0 0.0 0.0 0.0) in m)
-                      (\_ -> _rhs undefined)
+                      (\(_ :: _) -> _rhs undefined)
                       l)
                     j)
                   h)
@@ -214,23 +218,23 @@ zero
               f)
             e
             (match'Bool
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs undefined)
                 (\(n :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs undefined)
                   (\(o :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs let p = _rhs (V2 False False) in p)
                     (\(q :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs let r = _rhs (V3 False False False) in r)
                       (\(s :: _) -> case'Nat
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (_rhs let t = _rhs (V4 False False False False) in t)
-                        (\_ -> _rhs undefined)
+                        (\(_ :: _) -> _rhs undefined)
                         s)
                       q)
                     o)
@@ -239,42 +243,46 @@ zero
               e
               (_rhs undefined)))
           a
-          (match'Bool (\_ -> _) (_rhs let u = _rhs False in u) a (_rhs undefined)))))
+          (match'Bool
+            (\(_ :: _) -> _)
+            (_rhs let u = _rhs False in u)
+            a
+            (_rhs undefined)))))
 
 one :: forall a . Component a => a
 one
-  = \ @a @_ -> match'Int
-    (\_ -> _)
+  = \ @a @(_ :: _) -> match'Int
+    (\(_ :: _) -> _)
     (_rhs let b = _rhs (fromInt 1 :: Int) in b)
     a
     (match'Word
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs let c = _rhs (fromInt 1 :: Word) in c)
       a
       (match'Float
-        (\_ -> _)
+        (\(_ :: _) -> _)
         (_rhs let d = _rhs 1.0 in d)
         a
         (match'VecS
-          (\_ -> _)
+          (\(_ :: _) -> _)
           (\(e :: _) (f :: _) -> match'Float
-            (\_ -> _)
+            (\(_ :: _) -> _)
             (case'Nat
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (_rhs undefined)
               (\(g :: _) -> case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs undefined)
                 (\(h :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs let i = _rhs (V2 1.0 1.0) in i)
                   (\(j :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs let k = _rhs (V3 1.0 1.0 1.0) in k)
                     (\(l :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs let m = _rhs (V4 1.0 1.0 1.0 1.0) in m)
-                      (\_ -> _rhs undefined)
+                      (\(_ :: _) -> _rhs undefined)
                       l)
                     j)
                   h)
@@ -282,23 +290,23 @@ one
               f)
             e
             (match'Bool
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs undefined)
                 (\(n :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs undefined)
                   (\(o :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs let p = _rhs (V2 True True) in p)
                     (\(q :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs let r = _rhs (V3 True True True) in r)
                       (\(s :: _) -> case'Nat
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (_rhs let t = _rhs (V4 True True True True) in t)
-                        (\_ -> _rhs undefined)
+                        (\(_ :: _) -> _rhs undefined)
                         s)
                       q)
                     o)
@@ -307,16 +315,20 @@ one
               e
               (_rhs undefined)))
           a
-          (match'Bool (\_ -> _) (_rhs let u = _rhs True in u) a (_rhs undefined)))))
+          (match'Bool
+            (\(_ :: _) -> _)
+            (_rhs let u = _rhs True in u)
+            a
+            (_rhs undefined)))))
 
 'Integral :: Type -> Constraint
 'Integral
   = \(a :: _) -> match'Int
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs 'CUnit)
     a
     (match'Word
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs 'CUnit)
       a
       (_rhs ('CEmpty "no instance of 'Integral on ???")))
@@ -324,29 +336,29 @@ one
 'Floating :: Type -> Constraint
 'Floating
   = \(a :: _) -> match'Float
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs 'CUnit)
     a
     (match'VecS
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (\(b :: _) (c :: _) -> match'Float
-        (\_ -> _)
+        (\(_ :: _) -> _)
         (case'Nat
-          (\_ -> _)
+          (\(_ :: _) -> _)
           (_rhs ('CEmpty "no instance of 'Floating on ???"))
           (\(d :: _) -> case'Nat
-            (\_ -> _)
+            (\(_ :: _) -> _)
             (_rhs ('CEmpty "no instance of 'Floating on ???"))
             (\(e :: _) -> case'Nat
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (_rhs 'CUnit)
               (\(f :: _) -> case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs 'CUnit)
                 (\(g :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs 'CUnit)
-                  (\_ -> _rhs ('CEmpty "no instance of 'Floating on ???"))
+                  (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Floating on ???"))
                   g)
                 f)
               e)
@@ -356,119 +368,119 @@ one
         (_rhs ('CEmpty "no instance of 'Floating on ???")))
       a
       (match'Mat
-        (\_ -> _)
+        (\(_ :: _) -> _)
         (\(h :: _) (i :: _) (j :: _) -> case'Nat
-          (\_ -> _)
+          (\(_ :: _) -> _)
           (_rhs ('CEmpty "no instance of 'Floating on ???"))
           (\(k :: _) -> case'Nat
-            (\_ -> _)
+            (\(_ :: _) -> _)
             (_rhs ('CEmpty "no instance of 'Floating on ???"))
             (\(l :: _) -> case'Nat
-              (\_ -> _)
+              (\(_ :: _) -> _)
               (case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (_rhs ('CEmpty "no instance of 'Floating on ???"))
                 (\(m :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs ('CEmpty "no instance of 'Floating on ???"))
                   (\(n :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (match'Float
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs 'CUnit)
                       j
                       (_rhs ('CEmpty "no instance of 'Floating on ???")))
                     (\(o :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (match'Float
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (_rhs 'CUnit)
                         j
                         (_rhs ('CEmpty "no instance of 'Floating on ???")))
                       (\(p :: _) -> case'Nat
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (match'Float
-                          (\_ -> _)
+                          (\(_ :: _) -> _)
                           (_rhs 'CUnit)
                           j
                           (_rhs ('CEmpty "no instance of 'Floating on ???")))
-                        (\_ -> _rhs ('CEmpty "no instance of 'Floating on ???"))
+                        (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Floating on ???"))
                         p)
                       o)
                     n)
                   m)
                 i)
               (\(q :: _) -> case'Nat
-                (\_ -> _)
+                (\(_ :: _) -> _)
                 (case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (_rhs ('CEmpty "no instance of 'Floating on ???"))
                   (\(r :: _) -> case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs ('CEmpty "no instance of 'Floating on ???"))
                     (\(s :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (match'Float
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (_rhs 'CUnit)
                         j
                         (_rhs ('CEmpty "no instance of 'Floating on ???")))
                       (\(t :: _) -> case'Nat
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (match'Float
-                          (\_ -> _)
+                          (\(_ :: _) -> _)
                           (_rhs 'CUnit)
                           j
                           (_rhs ('CEmpty "no instance of 'Floating on ???")))
                         (\(u :: _) -> case'Nat
-                          (\_ -> _)
+                          (\(_ :: _) -> _)
                           (match'Float
-                            (\_ -> _)
+                            (\(_ :: _) -> _)
                             (_rhs 'CUnit)
                             j
                             (_rhs ('CEmpty "no instance of 'Floating on ???")))
-                          (\_ -> _rhs ('CEmpty "no instance of 'Floating on ???"))
+                          (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Floating on ???"))
                           u)
                         t)
                       s)
                     r)
                   i)
                 (\(v :: _) -> case'Nat
-                  (\_ -> _)
+                  (\(_ :: _) -> _)
                   (case'Nat
-                    (\_ -> _)
+                    (\(_ :: _) -> _)
                     (_rhs ('CEmpty "no instance of 'Floating on ???"))
                     (\(w :: _) -> case'Nat
-                      (\_ -> _)
+                      (\(_ :: _) -> _)
                       (_rhs ('CEmpty "no instance of 'Floating on ???"))
                       (\(x :: _) -> case'Nat
-                        (\_ -> _)
+                        (\(_ :: _) -> _)
                         (match'Float
-                          (\_ -> _)
+                          (\(_ :: _) -> _)
                           (_rhs 'CUnit)
                           j
                           (_rhs ('CEmpty "no instance of 'Floating on ???")))
                         (\(y :: _) -> case'Nat
-                          (\_ -> _)
+                          (\(_ :: _) -> _)
                           (match'Float
-                            (\_ -> _)
+                            (\(_ :: _) -> _)
                             (_rhs 'CUnit)
                             j
                             (_rhs ('CEmpty "no instance of 'Floating on ???")))
                           (\(z :: _) -> case'Nat
-                            (\_ -> _)
+                            (\(_ :: _) -> _)
                             (match'Float
-                              (\_ -> _)
+                              (\(_ :: _) -> _)
                               (_rhs 'CUnit)
                               j
                               (_rhs ('CEmpty "no instance of 'Floating on ???")))
-                            (\_ -> _rhs ('CEmpty "no instance of 'Floating on ???"))
+                            (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Floating on ???"))
                             z)
                           y)
                         x)
                       w)
                     i)
-                  (\_ -> _rhs ('CEmpty "no instance of 'Floating on ???"))
+                  (\(_ :: _) -> _rhs ('CEmpty "no instance of 'Floating on ???"))
                   v)
                 q)
               l)
@@ -766,18 +778,22 @@ PrimNoise3 :: forall (a :: _) . VecScalar a Float -> Vec (fromInt 3) Float
 PrimNoise4 :: forall (a :: _) . VecScalar a Float -> Vec (fromInt 4) Float
 
 head
-  = \(a :: _) -> case'List (\_ -> _) (_rhs undefined) (\(b :: _) _ -> _rhs b) a
+  = \(a :: _) -> case'List
+    (\(_ :: _) -> _)
+    (_rhs undefined)
+    (\(b :: _) (_ :: _) -> _rhs b)
+    a
 
 (++)
   = \(a :: _) (b :: _) -> case'List
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs b)
     (\(c :: _) (d :: _) -> _rhs (c : d ++ b))
     a
 
 foldr
   = \(a :: _) (b :: _) (c :: _) -> case'List
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs b)
     (\(d :: _) (e :: _) -> _rhs (a d (foldr a b e)))
     c
@@ -786,7 +802,7 @@ concat = _rhs (foldr (++) [])
 
 map
   = \(a :: _) (b :: _) -> case'List
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs [])
     (\(c :: _) (d :: _) -> _rhs (a c : map a d))
     b
@@ -796,9 +812,9 @@ concatMap = \(a :: _) (b :: _) -> _rhs (concat (map a b))
 
 len
   = \(a :: _) -> case'List
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs (fromInt 0))
-    (\_ (b :: _) -> _rhs (fromInt 1 `primAddInt` len b))
+    (\(_ :: _) (b :: _) -> _rhs (fromInt 1 `primAddInt` len b))
     a
 
 data Maybe (_ :: Type) :: Type where
@@ -832,7 +848,8 @@ mapPrimitives
 mapPrimitives = \(a :: _) -> _rhs (map (mapPrimitive a))
 
 'ListElem :: Type -> Type
-'ListElem = \(a :: _) -> match'List (\_ -> _) (\(b :: _) -> _rhs b) a undefined
+'ListElem
+  = \(a :: _) -> match'List (\(_ :: _) -> _) (\(b :: _) -> _rhs b) a undefined
 
 fetchArrays
   :: forall (a :: _) (b :: _) (c :: _)
@@ -854,10 +871,16 @@ data SimpleFragment (_ :: Type) :: Type where
 'Fragment = \(a :: _) (b :: _) -> _rhs ('Vector a ('Maybe ('SimpleFragment b)))
 
 sFragmentCoords
-  = \(a :: _) -> case'SimpleFragment (\_ -> _) (\(b :: _) _ -> _rhs b) a
+  = \(a :: _) -> case'SimpleFragment
+    (\(_ :: _) -> _)
+    (\(b :: _) (_ :: _) -> _rhs b)
+    a
 
 sFragmentValue
-  = \(a :: _) -> case'SimpleFragment (\_ -> _) (\_ (b :: _) -> _rhs b) a
+  = \(a :: _) -> case'SimpleFragment
+    (\(_ :: _) -> _)
+    (\(_ :: _) (b :: _) -> _rhs b)
+    a
 
 'FragmentStream = \(a :: _) (b :: _) -> _rhs ['Fragment a b]
 
@@ -893,7 +916,7 @@ data ImageKind :: Type where
 imageType :: ImageKind -> Type
 imageType
   = \(a :: _) -> case'ImageKind
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (\(b :: _) -> _rhs b)
     (_rhs 'Float)
     (_rhs 'Int)
@@ -923,23 +946,23 @@ data Swizz :: Type where
 swizzscalar :: forall (a :: _) (b :: _) . Vec b a -> Swizz -> a
 swizzscalar
   = \(a :: _) (b :: _) -> case'VecS
-    (\_ _ -> _)
+    (\(_ :: _) (_ :: _) -> _)
     (\(c :: _) (d :: _) -> case'Swizz
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs c)
       (_rhs d)
       (_rhs undefined)
       (_rhs undefined)
       b)
     (\(e :: _) (f :: _) (g :: _) -> case'Swizz
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs e)
       (_rhs f)
       (_rhs g)
       (_rhs undefined)
       b)
     (\(h :: _) (i :: _) (j :: _) (k :: _) -> case'Swizz
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs h)
       (_rhs i)
       (_rhs j)
@@ -950,17 +973,17 @@ swizzscalar
 definedVec :: forall (a :: _) (b :: _) . Vec b a -> Bool
 definedVec
   = \(a :: _) -> case'VecS
-    (\_ _ -> _)
-    (\_ _ -> _rhs True)
-    (\_ _ _ -> _rhs True)
-    (\_ _ _ _ -> _rhs True)
+    (\(_ :: _) (_ :: _) -> _)
+    (\(_ :: _) (_ :: _) -> _rhs True)
+    (\(_ :: _) (_ :: _) (_ :: _) -> _rhs True)
+    (\(_ :: _) (_ :: _) (_ :: _) (_ :: _) -> _rhs True)
     a
 
 swizzvector
   :: forall (a :: _) (b :: _) (c :: _) . Vec b a -> Vec c Swizz -> Vec c a
 swizzvector
   = \(a :: _) (b :: _) -> case'Bool
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs undefined)
     (_rhs (mapVec (swizzscalar a) b))
     (definedVec a)
@@ -1107,15 +1130,19 @@ rasterizePrimitives
 
 'ImageLC :: Type -> Nat
 'ImageLC
-  = \(a :: _) -> match'Image (\_ -> _) (\(b :: _) _ -> _rhs b) a undefined
+  = \(a :: _) -> match'Image
+    (\(_ :: _) -> _)
+    (\(b :: _) (_ :: _) -> _rhs b)
+    a
+    undefined
 
 allSame :: forall (a :: _) . [a] -> Constraint
 allSame
   = \(a :: _) -> case'List
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs 'CUnit)
     (\(b :: _) (c :: _) -> case'List
-      (\_ -> _)
+      (\(_ :: _) -> _)
       (_rhs 'CUnit)
       (\(d :: _) (e :: _) -> _rhs ('T2 (b `'EqCTt` d) (allSame (d : e))))
       c)
@@ -1129,11 +1156,11 @@ data FrameBuffer (_ :: Nat) (_ :: [ImageKind]) :: Type where
 imageType' :: [ImageKind] -> [Type]
 imageType'
   = \(a :: _) -> case'List
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (_rhs (map imageType a))
     (\(b :: _) (c :: _) -> case'ImageKind
-      (\_ -> _)
-      (\_ -> _rhs (map imageType a))
+      (\(_ :: _) -> _)
+      (\(_ :: _) -> _rhs (map imageType a))
       (_rhs (map imageType c))
       (_rhs (map imageType a))
       b)
@@ -1142,7 +1169,7 @@ imageType'
 'FragmentOperationKind :: Type -> ImageKind
 'FragmentOperationKind
   = \(a :: _) -> match'FragmentOperation
-    (\_ -> _)
+    (\(_ :: _) -> _)
     (\(b :: _) -> _rhs b)
     a
     undefined
@@ -1168,7 +1195,11 @@ infixl 0 overlay
 
 'GetImageKind :: Type -> ImageKind
 'GetImageKind
-  = \(a :: _) -> match'Image (\_ -> _) (\_ (b :: _) -> _rhs b) a undefined
+  = \(a :: _) -> match'Image
+    (\(_ :: _) -> _)
+    (\(_ :: _) (b :: _) -> _rhs b)
+    a
+    undefined
 
 FrameBuffer
   :: forall (a :: [Type])
@@ -1214,383 +1245,1287 @@ data Sampler :: Type where
 texture2D :: Sampler -> Vec (fromInt 2) Float -> Vec (fromInt 4) Float
 
 accumulationContext = \(a :: _) -> _rhs a
------------- trace
-id :: forall a . a -> a
-'VecS :: Type -> Nat -> Type
-V2 :: forall a . a -> a -> VecS a 2
-V3 :: forall a . a -> a -> a -> VecS a 3
-V4 :: forall a . a -> a -> a -> a -> VecS a 4
-case'VecS
-  :: forall a
-    . forall (b :: forall (c :: Nat) -> VecS a c -> Type)
-      -> (forall (d :: a) (e :: a) -> b 2 ('V2 d e))
-        -> (forall (f :: a) (g :: a) (h :: a) -> b 3 ('V3 f g h))
-          -> (forall (i :: a) (j :: a) (k :: a) (l :: a) -> b 4 ('V4 i j k l))
-            -> forall (m :: Nat) . forall (n :: VecS a m) -> b m n
-match'VecS
-  :: forall (a :: Type -> Type)
-    -> (forall b (c :: Nat) -> a (VecS b c)) -> forall d -> a d -> a d
-mapVec :: forall a b (c :: Nat) . (a -> b) -> VecS a c -> VecS b c
+------------ core code
+'BlendEquation :: Type
+'BlendEquation
+  = <<type constructor with 0 indices; constructors: FuncAdd, FuncSubtract, FuncReverseSubtract, Min, Max>>
+
+'Blending :: Type -> Type
+'Blending
+  = <<type constructor with 1 indices; constructors: NoBlending, BlendLogicOp, Blend>>
+
+'BlendingFactor :: Type
+'BlendingFactor
+  = <<type constructor with 0 indices; constructors: ZeroBF, OneBF, SrcColor, OneMinusSrcColor, DstColor, OneMinusDstColor, SrcAlpha, OneMinusSrcAlpha, DstAlpha, OneMinusDstAlpha, ConstantColor, OneMinusConstantColor, ConstantAlpha, OneMinusConstantAlpha, SrcAlphaSaturate>>
+
+'ComparisonFunction :: Type
+'ComparisonFunction
+  = <<type constructor with 0 indices; constructors: Never, Less, Equal, Lequal, Greater, Notequal, Gequal, Always>>
+
+'Component :: Type -> Constraint
+'Component
+  = \a -> match'Int
+    (\_ -> 'Constraint)
+    (_rhs CUnit)
+    a
+    (match'Word
+      (\_ -> 'Constraint)
+      (_rhs CUnit)
+      a
+      (match'Float
+        (\_ -> 'Constraint)
+        (_rhs CUnit)
+        a
+        (match'VecS
+          (\_ -> 'Constraint)
+          (\b c -> match'Float
+            (\_ -> 'Constraint)
+            (case'Nat
+              (\_ -> 'Constraint)
+              (_rhs (CEmpty "no instance of 'Component on ???"))
+              (\d -> case'Nat
+                (\_ -> 'Constraint)
+                (_rhs (CEmpty "no instance of 'Component on ???"))
+                (\e -> case'Nat
+                  (\_ -> 'Constraint)
+                  (_rhs CUnit)
+                  (\f -> case'Nat
+                    (\_ -> 'Constraint)
+                    (_rhs CUnit)
+                    (\g -> case'Nat
+                      (\_ -> 'Constraint)
+                      (_rhs CUnit)
+                      (\_ -> _rhs (CEmpty "no instance of 'Component on ???"))
+                      g)
+                    f)
+                  e)
+                d)
+              c)
+            b
+            (match'Bool
+              (\_ -> 'Constraint)
+              (case'Nat
+                (\_ -> 'Constraint)
+                (_rhs (CEmpty "no instance of 'Component on ???"))
+                (\h -> case'Nat
+                  (\_ -> 'Constraint)
+                  (_rhs (CEmpty "no instance of 'Component on ???"))
+                  (\i -> case'Nat
+                    (\_ -> 'Constraint)
+                    (_rhs CUnit)
+                    (\j -> case'Nat
+                      (\_ -> 'Constraint)
+                      (_rhs CUnit)
+                      (\k -> case'Nat
+                        (\_ -> 'Constraint)
+                        (_rhs CUnit)
+                        (\_ -> _rhs (CEmpty "no instance of 'Component on ???"))
+                        k)
+                      j)
+                    i)
+                  h)
+                c)
+              b
+              (_rhs (CEmpty "no instance of 'Component on ???"))))
+          a
+          (match'Bool
+            (\_ -> 'Constraint)
+            (_rhs CUnit)
+            a
+            (_rhs (CEmpty "no instance of 'Component on ???"))))))
+
+'CullMode :: Type
+'CullMode
+  = <<type constructor with 0 indices; constructors: CullFront, CullBack, CullNone>>
+
+'EdgeMode :: Type
+'EdgeMode
+  = <<type constructor with 0 indices; constructors: Repeat, MirroredRepeat, ClampToEdge>>
+
+'Filter :: Type
+'Filter
+  = <<type constructor with 0 indices; constructors: PointFilter, LinearFilter>>
+
+'Floating :: Type -> Constraint
+'Floating
+  = \a -> match'Float
+    (\_ -> 'Constraint)
+    (_rhs CUnit)
+    a
+    (match'VecS
+      (\_ -> 'Constraint)
+      (\b c -> match'Float
+        (\_ -> 'Constraint)
+        (case'Nat
+          (\_ -> 'Constraint)
+          (_rhs (CEmpty "no instance of 'Floating on ???"))
+          (\d -> case'Nat
+            (\_ -> 'Constraint)
+            (_rhs (CEmpty "no instance of 'Floating on ???"))
+            (\e -> case'Nat
+              (\_ -> 'Constraint)
+              (_rhs CUnit)
+              (\f -> case'Nat
+                (\_ -> 'Constraint)
+                (_rhs CUnit)
+                (\g -> case'Nat
+                  (\_ -> 'Constraint)
+                  (_rhs CUnit)
+                  (\_ -> _rhs (CEmpty "no instance of 'Floating on ???"))
+                  g)
+                f)
+              e)
+            d)
+          c)
+        b
+        (_rhs (CEmpty "no instance of 'Floating on ???")))
+      a
+      (match'Mat
+        (\_ -> 'Constraint)
+        (\h i j -> case'Nat
+          (\_ -> 'Constraint)
+          (_rhs (CEmpty "no instance of 'Floating on ???"))
+          (\k -> case'Nat
+            (\_ -> 'Constraint)
+            (_rhs (CEmpty "no instance of 'Floating on ???"))
+            (\l -> case'Nat
+              (\_ -> 'Constraint)
+              (case'Nat
+                (\_ -> 'Constraint)
+                (_rhs (CEmpty "no instance of 'Floating on ???"))
+                (\m -> case'Nat
+                  (\_ -> 'Constraint)
+                  (_rhs (CEmpty "no instance of 'Floating on ???"))
+                  (\n -> case'Nat
+                    (\_ -> 'Constraint)
+                    (match'Float
+                      (\_ -> 'Constraint)
+                      (_rhs CUnit)
+                      j
+                      (_rhs (CEmpty "no instance of 'Floating on ???")))
+                    (\o -> case'Nat
+                      (\_ -> 'Constraint)
+                      (match'Float
+                        (\_ -> 'Constraint)
+                        (_rhs CUnit)
+                        j
+                        (_rhs (CEmpty "no instance of 'Floating on ???")))
+                      (\p -> case'Nat
+                        (\_ -> 'Constraint)
+                        (match'Float
+                          (\_ -> 'Constraint)
+                          (_rhs CUnit)
+                          j
+                          (_rhs (CEmpty "no instance of 'Floating on ???")))
+                        (\_ -> _rhs (CEmpty "no instance of 'Floating on ???"))
+                        p)
+                      o)
+                    n)
+                  m)
+                i)
+              (\q -> case'Nat
+                (\_ -> 'Constraint)
+                (case'Nat
+                  (\_ -> 'Constraint)
+                  (_rhs (CEmpty "no instance of 'Floating on ???"))
+                  (\r -> case'Nat
+                    (\_ -> 'Constraint)
+                    (_rhs (CEmpty "no instance of 'Floating on ???"))
+                    (\s -> case'Nat
+                      (\_ -> 'Constraint)
+                      (match'Float
+                        (\_ -> 'Constraint)
+                        (_rhs CUnit)
+                        j
+                        (_rhs (CEmpty "no instance of 'Floating on ???")))
+                      (\t -> case'Nat
+                        (\_ -> 'Constraint)
+                        (match'Float
+                          (\_ -> 'Constraint)
+                          (_rhs CUnit)
+                          j
+                          (_rhs (CEmpty "no instance of 'Floating on ???")))
+                        (\u -> case'Nat
+                          (\_ -> 'Constraint)
+                          (match'Float
+                            (\_ -> 'Constraint)
+                            (_rhs CUnit)
+                            j
+                            (_rhs (CEmpty "no instance of 'Floating on ???")))
+                          (\_ -> _rhs (CEmpty "no instance of 'Floating on ???"))
+                          u)
+                        t)
+                      s)
+                    r)
+                  i)
+                (\v -> case'Nat
+                  (\_ -> 'Constraint)
+                  (case'Nat
+                    (\_ -> 'Constraint)
+                    (_rhs (CEmpty "no instance of 'Floating on ???"))
+                    (\w -> case'Nat
+                      (\_ -> 'Constraint)
+                      (_rhs (CEmpty "no instance of 'Floating on ???"))
+                      (\x -> case'Nat
+                        (\_ -> 'Constraint)
+                        (match'Float
+                          (\_ -> 'Constraint)
+                          (_rhs CUnit)
+                          j
+                          (_rhs (CEmpty "no instance of 'Floating on ???")))
+                        (\y -> case'Nat
+                          (\_ -> 'Constraint)
+                          (match'Float
+                            (\_ -> 'Constraint)
+                            (_rhs CUnit)
+                            j
+                            (_rhs (CEmpty "no instance of 'Floating on ???")))
+                          (\z -> case'Nat
+                            (\_ -> 'Constraint)
+                            (match'Float
+                              (\_ -> 'Constraint)
+                              (_rhs CUnit)
+                              j
+                              (_rhs (CEmpty "no instance of 'Floating on ???")))
+                            (\_ -> _rhs (CEmpty "no instance of 'Floating on ???"))
+                            z)
+                          y)
+                        x)
+                      w)
+                    i)
+                  (\_ -> _rhs (CEmpty "no instance of 'Floating on ???"))
+                  v)
+                q)
+              l)
+            k)
+          h)
+        a
+        (_rhs (CEmpty "no instance of 'Floating on ???"))))
+
+'Fragment :: Nat -> Type -> Type
+'Fragment = \a b -> _rhs ('Vector a ('Maybe ('SimpleFragment b)))
+
+'FragmentOperation :: ImageKind -> Type
+'FragmentOperation
+  = <<type constructor with 1 indices; constructors: ColorOp, DepthOp, StencilOp>>
+
+'FragmentOperationKind :: Type -> ImageKind
+'FragmentOperationKind
+  = \a -> match'FragmentOperation
+    (\_ -> 'ImageKind)
+    (\b -> _rhs b)
+    a
+    (undefined 'ImageKind)
+
+'FragmentStream :: Nat -> Type -> Type
+'FragmentStream = \a b -> _rhs ['Vector a ('Maybe ('SimpleFragment b))]
+
+'FrameBuffer :: Nat -> [ImageKind] -> Type
+'FrameBuffer = <<type constructor with 0 indices; constructors: >>
+
+'GetImageKind :: Type -> ImageKind
+'GetImageKind
+  = \a -> match'Image (\_ -> 'ImageKind) (\_ b -> _rhs b) a (undefined 'ImageKind)
+
+'Image :: Nat -> ImageKind -> Type
+'Image = <<type constructor with 0 indices; constructors: >>
+
+'ImageKind :: Type
+'ImageKind
+  = <<type constructor with 0 indices; constructors: Color, Depth, Stencil>>
+
+'ImageLC :: Type -> Nat
+'ImageLC = \a -> match'Image (\_ -> 'Nat) (\b _ -> _rhs b) a (undefined 'Nat)
+
+'Integral :: Type -> Constraint
+'Integral
+  = \a -> match'Int
+    (\_ -> 'Constraint)
+    (_rhs CUnit)
+    a
+    (match'Word
+      (\_ -> 'Constraint)
+      (_rhs CUnit)
+      a
+      (_rhs (CEmpty "no instance of 'Integral on ???")))
+
+'Interpolated :: Type -> Type
+'Interpolated
+  = <<type constructor with 0 indices; constructors: Smooth, NoPerspective, Flat>>
+
+'ListElem :: Type -> Type
+'ListElem = \a -> match'List (\_ -> Type) (\b -> _rhs b) a (undefined Type)
+
+'LogicOperation :: Type
+'LogicOperation
+  = <<type constructor with 0 indices; constructors: Clear, And, AndReverse, Copy, AndInverted, Noop, Xor, Or, Nor, Equiv, Invert, OrReverse, CopyInverted, OrInverted, Nand, Set>>
+
+'Mat :: Nat -> Nat -> Type -> Type
+'Mat
+  = <<type constructor with 3 indices; constructors: M22F, M32F, M42F, M23F, M33F, M43F, M24F, M34F, M44F>>
+
+'MatVecScalarElem :: Type -> Type
+'MatVecScalarElem
+  = \a -> match'Float
+    (\_ -> Type)
+    (_rhs 'Float)
+    a
+    (match'Bool
+      (\_ -> Type)
+      (_rhs 'Bool)
+      a
+      (match'Int
+        (\_ -> Type)
+        (_rhs 'Int)
+        a
+        (match'VecS
+          (\_ -> Type)
+          (\b _ -> _rhs b)
+          a
+          (match'Mat (\_ -> Type) (\_ _ c -> _rhs c) a (undefined Type)))))
+
+'Maybe :: Type -> Type
+'Maybe = <<type constructor with 0 indices; constructors: Nothing, Just>>
+
+'Output :: Type
+'Output = <<type constructor with 0 indices; constructors: ScreenOut>>
+
+'PointSize :: Type -> Type
+'PointSize
+  = <<type constructor with 0 indices; constructors: PointSize, ProgramPointSize>>
+
+'PointSpriteCoordOrigin :: Type
+'PointSpriteCoordOrigin
+  = <<type constructor with 0 indices; constructors: LowerLeft, UpperLeft>>
+
+'PolygonMode :: Type -> Type
+'PolygonMode
+  = <<type constructor with 0 indices; constructors: PolygonFill, PolygonPoint, PolygonLine>>
+
+'PolygonOffset :: Type
+'PolygonOffset
+  = <<type constructor with 0 indices; constructors: NoOffset, Offset>>
+
+'Primitive :: Type -> PrimitiveType -> Type
+'Primitive
+  = <<type constructor with 1 indices; constructors: PrimPoint, PrimLine, PrimTriangle>>
+
+'PrimitiveStream :: PrimitiveType -> Type -> Type
+'PrimitiveStream = \a b -> _rhs ['Primitive b a]
+
+'PrimitiveType :: Type
+'PrimitiveType
+  = <<type constructor with 0 indices; constructors: Triangle, Line, Point, TriangleAdjacency, LineAdjacency>>
+
+'ProvokingVertex :: Type
+'ProvokingVertex
+  = <<type constructor with 0 indices; constructors: LastVertex, FirstVertex>>
+
+'RasterContext :: Type -> PrimitiveType -> Type
+'RasterContext
+  = <<type constructor with 1 indices; constructors: TriangleCtx, PointCtx, LineCtx>>
+
+'Sampler :: Type
+'Sampler = <<type constructor with 0 indices; constructors: Sampler>>
+
+'Signed :: Type -> Constraint
+'Signed
+  = \a -> match'Int
+    (\_ -> 'Constraint)
+    (_rhs CUnit)
+    a
+    (match'Float
+      (\_ -> 'Constraint)
+      (_rhs CUnit)
+      a
+      (_rhs (CEmpty "no instance of 'Signed on ???")))
+
+'SimpleFragment :: Type -> Type
+'SimpleFragment
+  = <<type constructor with 0 indices; constructors: SimpleFragment>>
+
+'StencilOperation :: Type
+'StencilOperation
+  = <<type constructor with 0 indices; constructors: OpZero, OpKeep, OpReplace, OpIncr, OpIncrWrap, OpDecr, OpDecrWrap, OpInvert>>
+
+'StencilOps :: Type
+'StencilOps = <<type constructor with 0 indices; constructors: >>
+
+'StencilTests :: Type
+'StencilTests = <<type constructor with 0 indices; constructors: >>
+
+'Swizz :: Type
+'Swizz = <<type constructor with 0 indices; constructors: Sx, Sy, Sz, Sw>>
+
+'Texture :: Type
+'Texture
+  = <<type constructor with 0 indices; constructors: Texture2DSlot, Texture2D>>
+
 'Vec :: Nat -> Type -> Type
+'Vec = \a b -> _rhs ('VecS b a)
+
+'VecS :: Type -> Nat -> Type
+'VecS = <<type constructor with 1 indices; constructors: V2, V3, V4>>
+
 'VecScalar :: Nat -> Type -> Type
-'Mat :: Nat -> Nat -> Type -> Type
+'VecScalar
+  = \a b -> case'Nat
+    (\_ -> Type)
+    (undefined Type)
+    (\c -> case'Nat (\_ -> Type) (_rhs b) (\d -> _rhs ('VecS b (Succ (Succ d)))) c)
+    a
+
+'Vector :: Nat -> Type -> Type
+'Vector = <<type constructor with 0 indices; constructors: >>
+
+++ :: forall a . [a] -> [a] -> [a]
+++
+  = \a -> primFix
+    ([a] -> [a] -> [a])
+    \b c d -> case'List (\_ -> [a]) (_rhs d) (\e f -> _rhs (e : b f d)) c
+
+Accumulate
+  :: forall (a :: [ImageKind]) (b :: Nat) (c :: [Type])
+    . (a ~ (map Type ImageKind FragmentOperationKind c :: [ImageKind]))
+      => HList c
+        -> FragmentStream b (HList (imageType' a)) -> FrameBuffer b a -> FrameBuffer b a
+Accumulate = \a b c d e f g -> <<builtin>>
+
+Always :: ComparisonFunction
+Always = <<7th constructor of 'ComparisonFunction>>
+
+And :: LogicOperation
+And = <<1st constructor of 'LogicOperation>>
+
+AndInverted :: LogicOperation
+AndInverted = <<4th constructor of 'LogicOperation>>
+
+AndReverse :: LogicOperation
+AndReverse = <<2nd constructor of 'LogicOperation>>
+
+Attribute :: forall a . String -> a
+Attribute = \a b -> <<builtin>>
+
+Blend
+  :: (BlendEquation, BlendEquation)
+    -> ((BlendingFactor, BlendingFactor), (BlendingFactor, BlendingFactor))
+      -> Vec 4 Float -> Blending Float
+Blend = <<2nd constructor of 'Blending>>
+
+BlendLogicOp :: forall a . Integral a => LogicOperation -> Blending a
+BlendLogicOp = <<1st constructor of 'Blending>>
+
+ClampToEdge :: EdgeMode
+ClampToEdge = <<2nd constructor of 'EdgeMode>>
+
+Clear :: LogicOperation
+Clear = <<0th constructor of 'LogicOperation>>
+
+Color :: Type -> ImageKind
+Color = <<0th constructor of 'ImageKind>>
+
+ColorImage
+  :: forall (a :: Nat) (b :: Nat) c d
+    . (Num c, d ~ VecScalar b c) => d -> Image a ('Color d)
+ColorImage = \a b c d e f g -> <<builtin>>
+
+ColorOp
+  :: forall a (b :: Nat)
+    . Num a
+      => Blending a -> VecScalar b Bool -> FragmentOperation ('Color (VecScalar b a))
+ColorOp = <<0th constructor of 'FragmentOperation>>
+
+ConstantAlpha :: BlendingFactor
+ConstantAlpha = <<12th constructor of 'BlendingFactor>>
+
+ConstantColor :: BlendingFactor
+ConstantColor = <<10th constructor of 'BlendingFactor>>
+
+Copy :: LogicOperation
+Copy = <<3rd constructor of 'LogicOperation>>
+
+CopyInverted :: LogicOperation
+CopyInverted = <<12th constructor of 'LogicOperation>>
+
+CullBack :: CullMode
+CullBack = <<1st constructor of 'CullMode>>
+
+CullFront :: CullMode
+CullFront = <<0th constructor of 'CullMode>>
+
+CullNone :: CullMode
+CullNone = <<2nd constructor of 'CullMode>>
+
+Depth :: ImageKind
+Depth = <<1st constructor of 'ImageKind>>
+
+DepthImage :: forall (a :: Nat) . Float -> Image a 'Depth
+DepthImage = \a b -> <<builtin>>
+
+DepthOp :: ComparisonFunction -> Bool -> FragmentOperation 'Depth
+DepthOp = <<1st constructor of 'FragmentOperation>>
+
+DstAlpha :: BlendingFactor
+DstAlpha = <<8th constructor of 'BlendingFactor>>
+
+DstColor :: BlendingFactor
+DstColor = <<4th constructor of 'BlendingFactor>>
+
+Equal :: ComparisonFunction
+Equal = <<2nd constructor of 'ComparisonFunction>>
+
+Equiv :: LogicOperation
+Equiv = <<9th constructor of 'LogicOperation>>
+
+FirstVertex :: ProvokingVertex
+FirstVertex = <<1st constructor of 'ProvokingVertex>>
+
+Flat :: forall a . Interpolated a
+Flat = <<2nd constructor of 'Interpolated>>
+
+FrameBuffer
+  :: forall (a :: [Type])
+    . sameLayerCounts a
+      => HList a
+        -> FrameBuffer (ImageLC (head Type a)) (map Type ImageKind GetImageKind a)
+FrameBuffer = \a b c -> <<builtin>>
+
+FuncAdd :: BlendEquation
+FuncAdd = <<0th constructor of 'BlendEquation>>
+
+FuncReverseSubtract :: BlendEquation
+FuncReverseSubtract = <<2nd constructor of 'BlendEquation>>
+
+FuncSubtract :: BlendEquation
+FuncSubtract = <<1st constructor of 'BlendEquation>>
+
+Gequal :: ComparisonFunction
+Gequal = <<6th constructor of 'ComparisonFunction>>
+
+Greater :: ComparisonFunction
+Greater = <<4th constructor of 'ComparisonFunction>>
+
+Invert :: LogicOperation
+Invert = <<10th constructor of 'LogicOperation>>
+
+Just :: forall a . a -> Maybe a
+Just = <<1st constructor of 'Maybe>>
+
+LastVertex :: ProvokingVertex
+LastVertex = <<0th constructor of 'ProvokingVertex>>
+
+Lequal :: ComparisonFunction
+Lequal = <<3rd constructor of 'ComparisonFunction>>
+
+Less :: ComparisonFunction
+Less = <<1st constructor of 'ComparisonFunction>>
+
+Line :: PrimitiveType
+Line = <<1st constructor of 'PrimitiveType>>
+
+LineAdjacency :: PrimitiveType
+LineAdjacency = <<4th constructor of 'PrimitiveType>>
+
+LineCtx :: forall a . Float -> ProvokingVertex -> RasterContext a 'Line
+LineCtx = <<2nd constructor of 'RasterContext>>
+
+LinearFilter :: Filter
+LinearFilter = <<1st constructor of 'Filter>>
+
+LowerLeft :: PointSpriteCoordOrigin
+LowerLeft = <<0th constructor of 'PointSpriteCoordOrigin>>
+
 M22F :: Vec 2 Float -> Vec 2 Float -> Mat 2 2 Float
-M32F :: Vec 3 Float -> Vec 3 Float -> Mat 3 2 Float
-M42F :: Vec 4 Float -> Vec 4 Float -> Mat 4 2 Float
+M22F = <<0th constructor of 'Mat>>
+
 M23F :: Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Mat 2 3 Float
-M33F :: Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Mat 3 3 Float
-M43F :: Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Mat 4 3 Float
+M23F = <<3rd constructor of 'Mat>>
+
 M24F
   :: Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Mat 2 4 Float
+M24F = <<6th constructor of 'Mat>>
+
+M32F :: Vec 3 Float -> Vec 3 Float -> Mat 3 2 Float
+M32F = <<1st constructor of 'Mat>>
+
+M33F :: Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Mat 3 3 Float
+M33F = <<4th constructor of 'Mat>>
+
 M34F
   :: Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Mat 3 4 Float
+M34F = <<7th constructor of 'Mat>>
+
+M42F :: Vec 4 Float -> Vec 4 Float -> Mat 4 2 Float
+M42F = <<2nd constructor of 'Mat>>
+
+M43F :: Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Mat 4 3 Float
+M43F = <<5th constructor of 'Mat>>
+
 M44F
   :: Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Mat 4 4 Float
-case'Mat
-  :: forall (a :: forall (b :: Nat) (c :: Nat) d -> Mat b c d -> Type)
-    -> (forall (e :: Vec 2 Float) (f :: Vec 2 Float) -> a 2 2 Float ('M22F e f))
-      -> (forall (g :: Vec 3 Float) (h :: Vec 3 Float) -> a 3 2 Float ('M32F g h))
-        -> (forall (i :: Vec 4 Float) (j :: Vec 4 Float) -> a 4 2 Float ('M42F i j))
-          -> (forall (k :: Vec 2 Float) (l :: Vec 2 Float) (m :: Vec 2 Float)
-              -> a 2 3 Float ('M23F k l m))
-            -> (forall (n :: Vec 3 Float) (o :: Vec 3 Float) (p :: Vec 3 Float)
-                -> a 3 3 Float ('M33F n o p))
-              -> (forall (q :: Vec 4 Float) (r :: Vec 4 Float) (s :: Vec 4 Float)
-                  -> a 4 3 Float ('M43F q r s))
-                -> (forall (t :: Vec 2 Float)
-                      (u :: Vec 2 Float) (v :: Vec 2 Float) (w :: Vec 2 Float)
-                    -> a 2 4 Float ('M24F t u v w))
-                  -> (forall (x :: Vec 3 Float)
-                        (y :: Vec 3 Float) (z :: Vec 3 Float) (a' :: Vec 3 Float)
-                      -> a 3 4 Float ('M34F x y z a'))
-                    -> (forall (b' :: Vec 4 Float)
-                          (c' :: Vec 4 Float) (d' :: Vec 4 Float) (e' :: Vec 4 Float)
-                        -> a 4 4 Float ('M44F b' c' d' e'))
-                      -> forall (f' :: Nat) (g' :: Nat) h'
-                        . forall (i' :: Mat f' g' h') -> a f' g' h' i'
-match'Mat
-  :: forall (a :: Type -> Type)
-    -> (forall (b :: Nat) (c :: Nat) d -> a (Mat b c d)) -> forall e -> a e -> a e
-'MatVecScalarElem :: Type -> Type
-'Signed :: Type -> Constraint
-'Component :: Type -> Constraint
-zero :: forall a . Component a => a
-one :: forall a . Component a => a
-'Integral :: Type -> Constraint
-'Floating :: Type -> Constraint
+M44F = <<8th constructor of 'Mat>>
+
+Max :: BlendEquation
+Max = <<4th constructor of 'BlendEquation>>
+
+Min :: BlendEquation
+Min = <<3rd constructor of 'BlendEquation>>
+
+MirroredRepeat :: EdgeMode
+MirroredRepeat = <<1st constructor of 'EdgeMode>>
+
+Nand :: LogicOperation
+Nand = <<14th constructor of 'LogicOperation>>
+
+Never :: ComparisonFunction
+Never = <<0th constructor of 'ComparisonFunction>>
+
+NoBlending :: forall a . Blending a
+NoBlending = <<0th constructor of 'Blending>>
+
+NoOffset :: PolygonOffset
+NoOffset = <<0th constructor of 'PolygonOffset>>
+
+NoPerspective :: forall a . Floating a => Interpolated a
+NoPerspective = <<1st constructor of 'Interpolated>>
+
+Noop :: LogicOperation
+Noop = <<5th constructor of 'LogicOperation>>
+
+Nor :: LogicOperation
+Nor = <<8th constructor of 'LogicOperation>>
+
+Notequal :: ComparisonFunction
+Notequal = <<5th constructor of 'ComparisonFunction>>
+
+Nothing :: forall a . Maybe a
+Nothing = <<0th constructor of 'Maybe>>
+
+Offset :: Float -> Float -> PolygonOffset
+Offset = <<1st constructor of 'PolygonOffset>>
+
+OneBF :: BlendingFactor
+OneBF = <<1st constructor of 'BlendingFactor>>
+
+OneMinusConstantAlpha :: BlendingFactor
+OneMinusConstantAlpha = <<13th constructor of 'BlendingFactor>>
+
+OneMinusConstantColor :: BlendingFactor
+OneMinusConstantColor = <<11th constructor of 'BlendingFactor>>
+
+OneMinusDstAlpha :: BlendingFactor
+OneMinusDstAlpha = <<9th constructor of 'BlendingFactor>>
+
+OneMinusDstColor :: BlendingFactor
+OneMinusDstColor = <<5th constructor of 'BlendingFactor>>
+
+OneMinusSrcAlpha :: BlendingFactor
+OneMinusSrcAlpha = <<7th constructor of 'BlendingFactor>>
+
+OneMinusSrcColor :: BlendingFactor
+OneMinusSrcColor = <<3rd constructor of 'BlendingFactor>>
+
+OpDecr :: StencilOperation
+OpDecr = <<5th constructor of 'StencilOperation>>
+
+OpDecrWrap :: StencilOperation
+OpDecrWrap = <<6th constructor of 'StencilOperation>>
+
+OpIncr :: StencilOperation
+OpIncr = <<3rd constructor of 'StencilOperation>>
+
+OpIncrWrap :: StencilOperation
+OpIncrWrap = <<4th constructor of 'StencilOperation>>
+
+OpInvert :: StencilOperation
+OpInvert = <<7th constructor of 'StencilOperation>>
+
+OpKeep :: StencilOperation
+OpKeep = <<1st constructor of 'StencilOperation>>
+
+OpReplace :: StencilOperation
+OpReplace = <<2nd constructor of 'StencilOperation>>
+
+OpZero :: StencilOperation
+OpZero = <<0th constructor of 'StencilOperation>>
+
+Or :: LogicOperation
+Or = <<7th constructor of 'LogicOperation>>
+
+OrInverted :: LogicOperation
+OrInverted = <<13th constructor of 'LogicOperation>>
+
+OrReverse :: LogicOperation
+OrReverse = <<11th constructor of 'LogicOperation>>
+
+Point :: PrimitiveType
+Point = <<2nd constructor of 'PrimitiveType>>
+
+PointCtx
+  :: forall a
+    . PointSize a -> Float -> PointSpriteCoordOrigin -> RasterContext a 'Point
+PointCtx = <<1st constructor of 'RasterContext>>
+
+PointFilter :: Filter
+PointFilter = <<0th constructor of 'Filter>>
+
+PointSize :: forall a . Float -> PointSize a
+PointSize = <<0th constructor of 'PointSize>>
+
+PolygonFill :: forall a . PolygonMode a
+PolygonFill = <<0th constructor of 'PolygonMode>>
+
+PolygonLine :: forall a . Float -> PolygonMode a
+PolygonLine = <<2nd constructor of 'PolygonMode>>
+
+PolygonPoint :: forall a . PointSize a -> PolygonMode a
+PolygonPoint = <<1st constructor of 'PolygonMode>>
+
+PrimACos :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimACos = \a b c d -> <<builtin>>
+
+PrimACosH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimACosH = \a b c d -> <<builtin>>
+
+PrimASin :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimASin = \a b c d -> <<builtin>>
+
+PrimASinH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimASinH = \a b c d -> <<builtin>>
+
+PrimATan :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimATan = \a b c d -> <<builtin>>
+
+PrimATan2 :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
+PrimATan2 = \a b c d e -> <<builtin>>
+
+PrimATanH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimATanH = \a b c d -> <<builtin>>
+
+PrimAbs :: forall a b (c :: Nat) . (Signed a, b ~ VecScalar c a) => b -> b
+PrimAbs = \a b c d e f -> <<builtin>>
+
 PrimAdd :: forall a . Num (MatVecScalarElem a) => a -> a -> a
-PrimSub :: forall a . Num (MatVecScalarElem a) => a -> a -> a
-PrimMul :: forall a . Num (MatVecScalarElem a) => a -> a -> a
+PrimAdd = \a b c d -> <<builtin>>
+
 PrimAddS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
-PrimSubS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
-PrimMulS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
-PrimDiv :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
-PrimMod :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
-PrimDivS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
-PrimModS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
-PrimNeg :: forall a . Signed (MatVecScalarElem a) => a -> a
+PrimAddS = \a b c d e f -> <<builtin>>
+
+PrimAll :: forall (a :: Nat) . VecScalar a Bool -> Bool
+PrimAll = \a b -> <<builtin>>
+
+PrimAnd :: Bool -> Bool -> Bool
+PrimAnd = \a b -> <<builtin>>
+
+PrimAny :: forall (a :: Nat) . VecScalar a Bool -> Bool
+PrimAny = \a b -> <<builtin>>
+
 PrimBAnd
   :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
-PrimBOr
-  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
-PrimBXor
-  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
+PrimBAnd = \a b c d e f g -> <<builtin>>
+
 PrimBAndS
   :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
+PrimBAndS = \a b c d e f g -> <<builtin>>
+
+PrimBNot :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b
+PrimBNot = \a b c d e f -> <<builtin>>
+
+PrimBOr
+  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
+PrimBOr = \a b c d e f g -> <<builtin>>
+
 PrimBOrS
   :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
-PrimBXorS
-  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
-PrimBNot :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b
+PrimBOrS = \a b c d e f g -> <<builtin>>
+
 PrimBShiftL
   :: forall a b (c :: Nat) d
     . (Integral a, b ~ VecScalar c a, d ~ VecScalar c Word) => b -> d -> b
+PrimBShiftL = \a b c d e f g h i -> <<builtin>>
+
+PrimBShiftLS
+  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> Word -> b
+PrimBShiftLS = \a b c d e f g -> <<builtin>>
+
 PrimBShiftR
   :: forall a b (c :: Nat) d
     . (Integral a, b ~ VecScalar c a, d ~ VecScalar c Word) => b -> d -> b
-PrimBShiftLS
-  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> Word -> b
+PrimBShiftR = \a b c d e f g h i -> <<builtin>>
+
 PrimBShiftRS
   :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> Word -> b
-PrimAnd :: Bool -> Bool -> Bool
-PrimOr :: Bool -> Bool -> Bool
-PrimXor :: Bool -> Bool -> Bool
-PrimNot :: forall a (b :: Nat) . (a ~ VecScalar b Bool) => a -> a
-PrimAny :: forall (a :: Nat) . VecScalar a Bool -> Bool
-PrimAll :: forall (a :: Nat) . VecScalar a Bool -> Bool
-PrimACos :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimACosH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimASin :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimASinH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimATan :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimATanH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimCos :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimCosH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimDegrees :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimRadians :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimSin :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimSinH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimTan :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimTanH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimExp :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimLog :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimExp2 :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimLog2 :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimSqrt :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimInvSqrt :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimPow :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
-PrimATan2 :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
-PrimFloor :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimTrunc :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimRound :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimRoundEven :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimBShiftRS = \a b c d e f g -> <<builtin>>
+
+PrimBXor
+  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
+PrimBXor = \a b c d e f g -> <<builtin>>
+
+PrimBXorS
+  :: forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
+PrimBXorS = \a b c d e f g -> <<builtin>>
+
 PrimCeil :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimFract :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimMin :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
-PrimMax :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
-PrimMinS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
-PrimMaxS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
-PrimIsNan
-  :: forall a (b :: Nat) c
-    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c
-PrimIsInf
-  :: forall a (b :: Nat) c
-    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c
-PrimAbs :: forall a b (c :: Nat) . (Signed a, b ~ VecScalar c a) => b -> b
-PrimSign :: forall a b (c :: Nat) . (Signed a, b ~ VecScalar c a) => b -> b
-PrimModF :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> (a, a)
+PrimCeil = \a b c d -> <<builtin>>
+
 PrimClamp
   :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b -> b
+PrimClamp = \a b c d e f g h -> <<builtin>>
+
 PrimClampS
   :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> a -> b
-PrimMix :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
-PrimMixS
-  :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float -> a
-PrimMixB
-  :: forall a (b :: Nat) c
-    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> a -> c -> a
-PrimStep :: forall a (b :: Nat) . (a ~ VecS Float b) => a -> a -> a
-PrimStepS :: forall a (b :: Nat) . (a ~ VecScalar b Float) => Float -> a -> a
-PrimSmoothStep :: forall a (b :: Nat) . (a ~ VecS Float b) => a -> a -> a -> a
-PrimSmoothStepS
-  :: forall a (b :: Nat) . (a ~ VecScalar b Float) => Float -> Float -> a -> a
-PrimFloatBitsToInt :: forall (a :: Nat) . VecScalar a Float -> VecScalar a Int
-PrimFloatBitsToUInt :: forall (a :: Nat) . VecScalar a Float -> VecScalar a Word
-PrimIntBitsToFloat :: forall (a :: Nat) . VecScalar a Int -> VecScalar a Float
-PrimUIntBitsToFloat :: forall (a :: Nat) . VecScalar a Word -> VecScalar a Float
-PrimLength :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> Float
-PrimDistance :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float
-PrimDot :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float
+PrimClampS = \a b c d e f g h -> <<builtin>>
+
+PrimCos :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimCos = \a b c d -> <<builtin>>
+
+PrimCosH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimCosH = \a b c d -> <<builtin>>
+
 PrimCross :: forall a . (a ~ VecS Float 3) => a -> a -> a
-PrimNormalize :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimFaceForward
-  :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
-PrimRefract :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
-PrimReflect :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
-PrimTranspose :: forall (a :: Nat) (b :: Nat) c . Mat a b c -> Mat b a c
+PrimCross = \a b c d -> <<builtin>>
+
+PrimDFdx :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimDFdx = \a b c d -> <<builtin>>
+
+PrimDFdy :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimDFdy = \a b c d -> <<builtin>>
+
+PrimDegrees :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimDegrees = \a b c d -> <<builtin>>
+
 PrimDeterminant :: forall (a :: Nat) b . Mat a a b -> Float
-PrimInverse :: forall (a :: Nat) b . Mat a a b -> Mat a a b
-PrimOuterProduct
-  :: forall (a :: Nat) b (c :: Nat) . Vec a b -> Vec c b -> Mat c a b
-PrimMulMatVec
-  :: forall (a :: Nat) (b :: Nat) c . Mat a b c -> Vec b c -> Vec a c
-PrimMulVecMat
-  :: forall (a :: Nat) b (c :: Nat) . Vec a b -> Mat a c b -> Vec c b
-PrimMulMatMat
-  :: forall (a :: Nat) (b :: Nat) c (d :: Nat)
-    . Mat a b c -> Mat b d c -> Mat a d c
-PrimLessThan
-  :: forall a (b :: Nat) c d
-    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
-PrimLessThanEqual
+PrimDeterminant = \a b c -> <<builtin>>
+
+PrimDistance :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float
+PrimDistance = \a b c d e -> <<builtin>>
+
+PrimDiv :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
+PrimDiv = \a b c d e f g -> <<builtin>>
+
+PrimDivS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
+PrimDivS = \a b c d e f g -> <<builtin>>
+
+PrimDot :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float
+PrimDot = \a b c d e -> <<builtin>>
+
+PrimEqual :: forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
+PrimEqual = \a b c d e -> <<builtin>>
+
+PrimEqualV
   :: forall a (b :: Nat) c d
     . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
+PrimEqualV = \a b c d e f g h i -> <<builtin>>
+
+PrimExp :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimExp = \a b c d -> <<builtin>>
+
+PrimExp2 :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimExp2 = \a b c d -> <<builtin>>
+
+PrimFWidth :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimFWidth = \a b c d -> <<builtin>>
+
+PrimFaceForward
+  :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
+PrimFaceForward = \a b c d e f -> <<builtin>>
+
+PrimFloatBitsToInt :: forall (a :: Nat) . VecScalar a Float -> VecScalar a Int
+PrimFloatBitsToInt = \a b -> <<builtin>>
+
+PrimFloatBitsToUInt :: forall (a :: Nat) . VecScalar a Float -> VecScalar a Word
+PrimFloatBitsToUInt = \a b -> <<builtin>>
+
+PrimFloor :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimFloor = \a b c d -> <<builtin>>
+
+PrimFract :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimFract = \a b c d -> <<builtin>>
+
 PrimGreaterThan
   :: forall a (b :: Nat) c d
     . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
+PrimGreaterThan = \a b c d e f g h i -> <<builtin>>
+
 PrimGreaterThanEqual
   :: forall a (b :: Nat) c d
     . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
-PrimEqualV
+PrimGreaterThanEqual = \a b c d e f g h i -> <<builtin>>
+
+PrimIntBitsToFloat :: forall (a :: Nat) . VecScalar a Int -> VecScalar a Float
+PrimIntBitsToFloat = \a b -> <<builtin>>
+
+PrimInvSqrt :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimInvSqrt = \a b c d -> <<builtin>>
+
+PrimInverse :: forall (a :: Nat) b . Mat a a b -> Mat a a b
+PrimInverse = \a b c -> <<builtin>>
+
+PrimIsInf
+  :: forall a (b :: Nat) c
+    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c
+PrimIsInf = \a b c d e f -> <<builtin>>
+
+PrimIsNan
+  :: forall a (b :: Nat) c
+    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c
+PrimIsNan = \a b c d e f -> <<builtin>>
+
+PrimLength :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> Float
+PrimLength = \a b c d -> <<builtin>>
+
+PrimLessThan
   :: forall a (b :: Nat) c d
     . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
-PrimNotEqualV
+PrimLessThan = \a b c d e f g h i -> <<builtin>>
+
+PrimLessThanEqual
   :: forall a (b :: Nat) c d
     . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
-PrimEqual :: forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
-PrimNotEqual :: forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
-PrimDFdx :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimDFdy :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
-PrimFWidth :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimLessThanEqual = \a b c d e f g h i -> <<builtin>>
+
+PrimLine :: forall a . a -> a -> Primitive a 'Line
+PrimLine = <<1st constructor of 'Primitive>>
+
+PrimLog :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimLog = \a b c d -> <<builtin>>
+
+PrimLog2 :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimLog2 = \a b c d -> <<builtin>>
+
+PrimMax :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
+PrimMax = \a b c d e f g -> <<builtin>>
+
+PrimMaxS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
+PrimMaxS = \a b c d e f g -> <<builtin>>
+
+PrimMin :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
+PrimMin = \a b c d e f g -> <<builtin>>
+
+PrimMinS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
+PrimMinS = \a b c d e f g -> <<builtin>>
+
+PrimMix :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
+PrimMix = \a b c d e f -> <<builtin>>
+
+PrimMixB
+  :: forall a (b :: Nat) c
+    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> a -> c -> a
+PrimMixB = \a b c d e f g h -> <<builtin>>
+
+PrimMixS
+  :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float -> a
+PrimMixS = \a b c d e f -> <<builtin>>
+
+PrimMod :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
+PrimMod = \a b c d e f g -> <<builtin>>
+
+PrimModF :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> (a, a)
+PrimModF = \a b c d -> <<builtin>>
+
+PrimModS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
+PrimModS = \a b c d e f g -> <<builtin>>
+
+PrimMul :: forall a . Num (MatVecScalarElem a) => a -> a -> a
+PrimMul = \a b c d -> <<builtin>>
+
+PrimMulMatMat
+  :: forall (a :: Nat) (b :: Nat) c (d :: Nat)
+    . Mat a b c -> Mat b d c -> Mat a d c
+PrimMulMatMat = \a b c d e f -> <<builtin>>
+
+PrimMulMatVec
+  :: forall (a :: Nat) (b :: Nat) c . Mat a b c -> Vec b c -> Vec a c
+PrimMulMatVec = \a b c d e -> <<builtin>>
+
+PrimMulS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
+PrimMulS = \a b c d e f -> <<builtin>>
+
+PrimMulVecMat
+  :: forall (a :: Nat) b (c :: Nat) . Vec a b -> Mat a c b -> Vec c b
+PrimMulVecMat = \a b c d e -> <<builtin>>
+
+PrimNeg :: forall a . Signed (MatVecScalarElem a) => a -> a
+PrimNeg = \a b c -> <<builtin>>
+
 PrimNoise1 :: forall (a :: Nat) . VecScalar a Float -> Float
+PrimNoise1 = \a b -> <<builtin>>
+
 PrimNoise2 :: forall (a :: Nat) . VecScalar a Float -> Vec 2 Float
+PrimNoise2 = \a b -> <<builtin>>
+
 PrimNoise3 :: forall (a :: Nat) . VecScalar a Float -> Vec 3 Float
+PrimNoise3 = \a b -> <<builtin>>
+
 PrimNoise4 :: forall (a :: Nat) . VecScalar a Float -> Vec 4 Float
-head :: forall a . [a] -> a
-(++) :: forall a . [a] -> [a] -> [a]
-foldr :: forall a b . (b -> a -> a) -> a -> [b] -> a
-concat :: forall a . [[a]] -> [a]
-map :: forall a b . (a -> b) -> [a] -> [b]
-concatMap :: forall a b . (a -> [b]) -> [a] -> [b]
-len :: forall a . [a] -> Int
-'Maybe :: Type -> Type
-Nothing :: forall a . Maybe a
-Just :: forall a . a -> Maybe a
-case'Maybe
-  :: forall a
-    . forall (b :: Maybe a -> Type)
-      -> b 'Nothing
-        -> (forall (c :: a) -> b ('Just c)) -> forall (d :: Maybe a) -> b d
-match'Maybe
-  :: forall (a :: Type -> Type)
-    -> (forall b -> a (Maybe b)) -> forall c -> a c -> a c
-'Vector :: Nat -> Type -> Type
-case'Vector
-  :: forall (a :: Nat) b
-    . forall (c :: Vector a b -> Type) (d :: Vector a b) -> c d
-match'Vector
-  :: forall (a :: Type -> Type)
-    -> (forall (b :: Nat) c -> a (Vector b c)) -> forall d -> a d -> a d
-'PrimitiveType :: Type
-Triangle :: PrimitiveType
-Line :: PrimitiveType
-Point :: PrimitiveType
-TriangleAdjacency :: PrimitiveType
-LineAdjacency :: PrimitiveType
-case'PrimitiveType
-  :: forall (a :: PrimitiveType -> Type)
-    -> a 'Triangle
-      -> a 'Line
-        -> a 'Point
-          -> a 'TriangleAdjacency
-            -> a 'LineAdjacency -> forall (b :: PrimitiveType) -> a b
-match'PrimitiveType
-  :: forall (a :: Type -> Type) -> a PrimitiveType -> forall b -> a b -> a b
-'Primitive :: Type -> PrimitiveType -> Type
+PrimNoise4 = \a b -> <<builtin>>
+
+PrimNormalize :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimNormalize = \a b c d -> <<builtin>>
+
+PrimNot :: forall a (b :: Nat) . (a ~ VecScalar b Bool) => a -> a
+PrimNot = \a b c d -> <<builtin>>
+
+PrimNotEqual :: forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
+PrimNotEqual = \a b c d e -> <<builtin>>
+
+PrimNotEqualV
+  :: forall a (b :: Nat) c d
+    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
+PrimNotEqualV = \a b c d e f g h i -> <<builtin>>
+
+PrimOr :: Bool -> Bool -> Bool
+PrimOr = \a b -> <<builtin>>
+
+PrimOuterProduct
+  :: forall (a :: Nat) b (c :: Nat) . Vec a b -> Vec c b -> Mat c a b
+PrimOuterProduct = \a b c d e -> <<builtin>>
+
 PrimPoint :: forall a . a -> Primitive a 'Point
-PrimLine :: forall a . a -> a -> Primitive a 'Line
+PrimPoint = <<0th constructor of 'Primitive>>
+
+PrimPow :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
+PrimPow = \a b c d e -> <<builtin>>
+
+PrimRadians :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimRadians = \a b c d -> <<builtin>>
+
+PrimReflect :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
+PrimReflect = \a b c d e -> <<builtin>>
+
+PrimRefract :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
+PrimRefract = \a b c d e f -> <<builtin>>
+
+PrimRound :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimRound = \a b c d -> <<builtin>>
+
+PrimRoundEven :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimRoundEven = \a b c d -> <<builtin>>
+
+PrimSign :: forall a b (c :: Nat) . (Signed a, b ~ VecScalar c a) => b -> b
+PrimSign = \a b c d e f -> <<builtin>>
+
+PrimSin :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimSin = \a b c d -> <<builtin>>
+
+PrimSinH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimSinH = \a b c d -> <<builtin>>
+
+PrimSmoothStep :: forall a (b :: Nat) . (a ~ VecS Float b) => a -> a -> a -> a
+PrimSmoothStep = \a b c d e f -> <<builtin>>
+
+PrimSmoothStepS
+  :: forall a (b :: Nat) . (a ~ VecScalar b Float) => Float -> Float -> a -> a
+PrimSmoothStepS = \a b c d e f -> <<builtin>>
+
+PrimSqrt :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimSqrt = \a b c d -> <<builtin>>
+
+PrimStep :: forall a (b :: Nat) . (a ~ VecS Float b) => a -> a -> a
+PrimStep = \a b c d e -> <<builtin>>
+
+PrimStepS :: forall a (b :: Nat) . (a ~ VecScalar b Float) => Float -> a -> a
+PrimStepS = \a b c d e -> <<builtin>>
+
+PrimSub :: forall a . Num (MatVecScalarElem a) => a -> a -> a
+PrimSub = \a b c d -> <<builtin>>
+
+PrimSubS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
+PrimSubS = \a b c d e f -> <<builtin>>
+
+PrimTan :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimTan = \a b c d -> <<builtin>>
+
+PrimTanH :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimTanH = \a b c d -> <<builtin>>
+
+PrimTranspose :: forall (a :: Nat) (b :: Nat) c . Mat a b c -> Mat b a c
+PrimTranspose = \a b c d -> <<builtin>>
+
 PrimTriangle :: forall a . a -> a -> a -> Primitive a 'Triangle
-case'Primitive
-  :: forall a
-    . forall (b :: forall (c :: PrimitiveType) -> Primitive a c -> Type)
-      -> (forall (d :: a) -> b 'Point ('PrimPoint d))
-        -> (forall (e :: a) (f :: a) -> b 'Line ('PrimLine e f))
-          -> (forall (g :: a) (h :: a) (i :: a) -> b 'Triangle ('PrimTriangle g h i))
-            -> forall (j :: PrimitiveType) . forall (k :: Primitive a j) -> b j k
-match'Primitive
-  :: forall (a :: Type -> Type)
-    -> (forall b (c :: PrimitiveType) -> a (Primitive b c))
-      -> forall d -> a d -> a d
-mapPrimitive
-  :: forall a b (c :: PrimitiveType) . (a -> b) -> Primitive a c -> Primitive b c
-'PrimitiveStream :: PrimitiveType -> Type -> Type
-mapPrimitives
-  :: forall a b (c :: PrimitiveType)
-    . (a -> b) -> [Primitive a c] -> [Primitive b c]
-'ListElem :: Type -> Type
-fetchArrays
-  :: forall (a :: PrimitiveType) (b :: [Type]) (c :: [Type])
-    . (b ~ (map Type Type ListElem c :: [Type]))
-      => HList c -> PrimitiveStream a (HList b)
-fetch
-  :: forall (a :: PrimitiveType) (b :: [Type])
-    . String -> HList b -> PrimitiveStream a (HList b)
-Attribute :: forall a . String -> a
-fetchStream
-  :: forall (a :: PrimitiveType) (b :: [Type])
-    . String
-      -> forall (c :: [String])
-        -> (len String c ~ (len Type b :: Int)) => PrimitiveStream a (HList b)
-'SimpleFragment :: Type -> Type
+PrimTriangle = <<2nd constructor of 'Primitive>>
+
+PrimTrunc :: forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
+PrimTrunc = \a b c d -> <<builtin>>
+
+PrimUIntBitsToFloat :: forall (a :: Nat) . VecScalar a Word -> VecScalar a Float
+PrimUIntBitsToFloat = \a b -> <<builtin>>
+
+PrimXor :: Bool -> Bool -> Bool
+PrimXor = \a b -> <<builtin>>
+
+PrjImage :: forall (a :: ImageKind) . FrameBuffer 1 ' [a] -> Image 1 a
+PrjImage = \a b -> <<builtin>>
+
+PrjImageColor
+  :: FrameBuffer 1 ' ['Depth, 'Color (Vec 4 Float)]
+    -> Image 1 ('Color (Vec 4 Float))
+PrjImageColor = \a -> <<builtin>>
+
+ProgramPointSize :: forall a . (a -> Float) -> PointSize a
+ProgramPointSize = <<1st constructor of 'PointSize>>
+
+Repeat :: EdgeMode
+Repeat = <<0th constructor of 'EdgeMode>>
+
+Sampler :: Filter -> EdgeMode -> Texture -> Sampler
+Sampler = <<0th constructor of 'Sampler>>
+
+ScreenOut :: forall (a :: Nat) (b :: [ImageKind]) . FrameBuffer a b -> Output
+ScreenOut = <<0th constructor of 'Output>>
+
+Set :: LogicOperation
+Set = <<15th constructor of 'LogicOperation>>
+
 SimpleFragment :: forall a . Vec 3 Float -> a -> SimpleFragment a
-case'SimpleFragment
-  :: forall a
-    . forall (b :: SimpleFragment a -> Type)
-      -> (forall (c :: Vec 3 Float) (d :: a) -> b ('SimpleFragment c d))
-        -> forall (e :: SimpleFragment a) -> b e
-match'SimpleFragment
-  :: forall (a :: Type -> Type)
-    -> (forall b -> a (SimpleFragment b)) -> forall c -> a c -> a c
-'Fragment :: Nat -> Type -> Type
-sFragmentCoords :: forall a . SimpleFragment a -> VecS Float 3
-sFragmentValue :: forall a . SimpleFragment a -> a
-'FragmentStream :: Nat -> Type -> Type
-customizeDepth
-  :: forall a (b :: Nat) . (a -> Float) -> Fragment b a -> Fragment b a
-customizeDepths
-  :: forall a (b :: Nat)
-    . (a -> Float)
-      -> [Vector b (Maybe (SimpleFragment a))]
-        -> [Vector b (Maybe (SimpleFragment a))]
-filterFragment
-  :: forall a (b :: Nat) . (a -> Bool) -> Fragment b a -> Fragment b a
-filterFragments
-  :: forall a (b :: Nat)
-    . (a -> Bool)
-      -> [Vector b (Maybe (SimpleFragment a))]
-        -> [Vector b (Maybe (SimpleFragment a))]
-mapFragment :: forall a b (c :: Nat) . (a -> b) -> Fragment c a -> Fragment c b
-mapFragments
-  :: forall a b (c :: Nat)
-    . (a -> b)
-      -> [Vector c (Maybe (SimpleFragment a))]
-        -> [Vector c (Maybe (SimpleFragment b))]
-'ImageKind :: Type
-Color :: Type -> ImageKind
-Depth :: ImageKind
+SimpleFragment = <<0th constructor of 'SimpleFragment>>
+
+Smooth :: forall a . Floating a => Interpolated a
+Smooth = <<0th constructor of 'Interpolated>>
+
+SrcAlpha :: BlendingFactor
+SrcAlpha = <<6th constructor of 'BlendingFactor>>
+
+SrcAlphaSaturate :: BlendingFactor
+SrcAlphaSaturate = <<14th constructor of 'BlendingFactor>>
+
+SrcColor :: BlendingFactor
+SrcColor = <<2nd constructor of 'BlendingFactor>>
+
 Stencil :: ImageKind
-case'ImageKind
-  :: forall (a :: ImageKind -> Type)
-    -> (forall b -> a ('Color b))
-      -> a 'Depth -> a 'Stencil -> forall (c :: ImageKind) -> a c
-match'ImageKind
-  :: forall (a :: Type -> Type) -> a ImageKind -> forall b -> a b -> a b
-imageType :: ImageKind -> Type
-'Image :: Nat -> ImageKind -> Type
-case'Image
-  :: forall (a :: Nat) (b :: ImageKind)
-    . forall (c :: Image a b -> Type) (d :: Image a b) -> c d
-match'Image
-  :: forall (a :: Type -> Type)
-    -> (forall (b :: Nat) (c :: ImageKind) -> a (Image b c))
-      -> forall d -> a d -> a d
-ColorImage
-  :: forall (a :: Nat) (b :: Nat) c d
-    . (Num c, d ~ VecScalar b c) => d -> Image a ('Color d)
-DepthImage :: forall (a :: Nat) . Float -> Image a 'Depth
+Stencil = <<2nd constructor of 'ImageKind>>
+
 StencilImage :: forall (a :: Nat) . Int -> Image a 'Stencil
-emptyDepthImage :: Float -> Image 1 'Depth
-emptyColorImage
-  :: forall (a :: Nat) b c . (Num b, c ~ VecScalar a b) => c -> Image 1 ('Color c)
-'Swizz :: Type
+StencilImage = \a b -> <<builtin>>
+
+StencilOp
+  :: StencilTests -> StencilOps -> StencilOps -> FragmentOperation 'Stencil
+StencilOp = <<2nd constructor of 'FragmentOperation>>
+
+Sw :: Swizz
+Sw = <<3rd constructor of 'Swizz>>
+
 Sx :: Swizz
+Sx = <<0th constructor of 'Swizz>>
+
 Sy :: Swizz
+Sy = <<1st constructor of 'Swizz>>
+
 Sz :: Swizz
-Sw :: Swizz
-case'Swizz
-  :: forall (a :: Swizz -> Type)
-    -> a 'Sx -> a 'Sy -> a 'Sz -> a 'Sw -> forall (b :: Swizz) -> a b
-match'Swizz :: forall (a :: Type -> Type) -> a Swizz -> forall b -> a b -> a b
-swizzscalar :: forall a (b :: Nat) . Vec b a -> Swizz -> a
-definedVec :: forall a (b :: Nat) . Vec b a -> Bool
-swizzvector
-  :: forall a (b :: Nat) (c :: Nat) . Vec b a -> Vec c Swizz -> VecS a c
-'BlendingFactor :: Type
+Sz = <<2nd constructor of 'Swizz>>
+
+Texture2D :: Vec 2 Int -> Image 1 ('Color (Vec 4 Float)) -> Texture
+Texture2D = <<1st constructor of 'Texture>>
+
+Texture2DSlot :: String -> Texture
+Texture2DSlot = <<0th constructor of 'Texture>>
+
+Triangle :: PrimitiveType
+Triangle = <<0th constructor of 'PrimitiveType>>
+
+TriangleAdjacency :: PrimitiveType
+TriangleAdjacency = <<3rd constructor of 'PrimitiveType>>
+
+TriangleCtx
+  :: forall a
+    . CullMode
+      -> PolygonMode a
+        -> PolygonOffset -> ProvokingVertex -> RasterContext a 'Triangle
+TriangleCtx = <<0th constructor of 'RasterContext>>
+
+Uniform :: forall a . String -> a
+Uniform = \a b -> <<builtin>>
+
+UpperLeft :: PointSpriteCoordOrigin
+UpperLeft = <<1st constructor of 'PointSpriteCoordOrigin>>
+
+V2 :: forall a . a -> a -> VecS a 2
+V2 = <<0th constructor of 'VecS>>
+
+V3 :: forall a . a -> a -> a -> VecS a 3
+V3 = <<1st constructor of 'VecS>>
+
+V4 :: forall a . a -> a -> a -> a -> VecS a 4
+V4 = <<2nd constructor of 'VecS>>
+
+Xor :: LogicOperation
+Xor = <<6th constructor of 'LogicOperation>>
+
 ZeroBF :: BlendingFactor
-OneBF :: BlendingFactor
-SrcColor :: BlendingFactor
-OneMinusSrcColor :: BlendingFactor
-DstColor :: BlendingFactor
-OneMinusDstColor :: BlendingFactor
-SrcAlpha :: BlendingFactor
-OneMinusSrcAlpha :: BlendingFactor
-DstAlpha :: BlendingFactor
-OneMinusDstAlpha :: BlendingFactor
-ConstantColor :: BlendingFactor
-OneMinusConstantColor :: BlendingFactor
-ConstantAlpha :: BlendingFactor
-OneMinusConstantAlpha :: BlendingFactor
-SrcAlphaSaturate :: BlendingFactor
+ZeroBF = <<0th constructor of 'BlendingFactor>>
+
+accumulate
+  :: forall (a :: Nat) (b :: [Type]) c
+    . HList b
+      -> (c -> HList (imageType' (map Type ImageKind FragmentOperationKind b)))
+        -> [Vector a (Maybe (SimpleFragment c))]
+          -> FrameBuffer a (map Type ImageKind FragmentOperationKind b)
+            -> FrameBuffer a (map Type ImageKind FragmentOperationKind b)
+accumulate
+  = \a b c d e f g -> _rhs
+    (Accumulate
+      (map Type 'ImageKind 'FragmentOperationKind b)
+      a
+      b
+      TT
+      d
+      (map
+        ('Vector a ('Maybe ('SimpleFragment c)))
+        ('Vector
+          a
+          ('Maybe
+            ('SimpleFragment
+              ('HList (imageType' (map Type 'ImageKind 'FragmentOperationKind b))))))
+        (\h -> mapFragment
+          c
+          ('HList (imageType' (map Type 'ImageKind 'FragmentOperationKind b)))
+          a
+          e
+          h)
+        f)
+      g)
+
+accumulateWith :: forall a b . a -> b -> (a, b)
+accumulateWith = \a b c d -> _rhs (c, d)
+
+accumulationContext :: forall a . a -> a
+accumulationContext = \_ a -> _rhs a
+
+allSame :: forall a . [a] -> Constraint
+allSame
+  = primFix
+    (forall a . [a] -> 'Constraint)
+    \b c d -> case'List
+      (\_ -> 'Constraint)
+      (_rhs CUnit)
+      (\e f -> case'List
+        (\_ -> 'Constraint)
+        (_rhs CUnit)
+        (\g h -> _rhs ('T2 (e ~ (g :: c)) (b c (g : h))))
+        f)
+      d
+
+case'BlendEquation
+  :: forall (a :: BlendEquation -> Type)
+    -> a 'FuncAdd
+      -> a 'FuncSubtract
+        -> a 'FuncReverseSubtract
+          -> a 'Min -> a 'Max -> forall (b :: BlendEquation) -> a b
+case'BlendEquation
+  = \a b c d e f g -> <<case function of a type with 0 parameters>>
+
+case'Blending
+  :: forall (a :: forall b -> Blending b -> Type)
+    -> (forall c . a c ('NoBlending c))
+      -> (forall d (e :: CW (Integral d))
+          . forall (f :: LogicOperation) -> a d ('BlendLogicOp d e f))
+        -> (forall (g :: (BlendEquation, BlendEquation))
+              (h :: ((BlendingFactor, BlendingFactor), (BlendingFactor, BlendingFactor)))
+                (i :: Vec 4 Float)
+            -> a Float ('Blend g h i))
+          -> forall j . forall (k :: Blending j) -> a j k
+case'Blending = \a b c d e f -> <<case function of a type with 0 parameters>>
+
 case'BlendingFactor
   :: forall (a :: BlendingFactor -> Type)
     -> a 'ZeroBF
@@ -1608,39 +2543,75 @@ case'BlendingFactor
                             -> a 'ConstantAlpha
                               -> a 'OneMinusConstantAlpha
                                 -> a 'SrcAlphaSaturate -> forall (b :: BlendingFactor) -> a b
-match'BlendingFactor
-  :: forall (a :: Type -> Type) -> a BlendingFactor -> forall b -> a b -> a b
-'BlendEquation :: Type
-FuncAdd :: BlendEquation
-FuncSubtract :: BlendEquation
-FuncReverseSubtract :: BlendEquation
-Min :: BlendEquation
-Max :: BlendEquation
-case'BlendEquation
-  :: forall (a :: BlendEquation -> Type)
-    -> a 'FuncAdd
-      -> a 'FuncSubtract
-        -> a 'FuncReverseSubtract
-          -> a 'Min -> a 'Max -> forall (b :: BlendEquation) -> a b
-match'BlendEquation
-  :: forall (a :: Type -> Type) -> a BlendEquation -> forall b -> a b -> a b
-'LogicOperation :: Type
-Clear :: LogicOperation
-And :: LogicOperation
-AndReverse :: LogicOperation
-Copy :: LogicOperation
-AndInverted :: LogicOperation
-Noop :: LogicOperation
-Xor :: LogicOperation
-Or :: LogicOperation
-Nor :: LogicOperation
-Equiv :: LogicOperation
-Invert :: LogicOperation
-OrReverse :: LogicOperation
-CopyInverted :: LogicOperation
-OrInverted :: LogicOperation
-Nand :: LogicOperation
-Set :: LogicOperation
+case'BlendingFactor
+  = \a b c d e f g h i j k l m n o p q
+    -> <<case function of a type with 0 parameters>>
+
+case'ComparisonFunction
+  :: forall (a :: ComparisonFunction -> Type)
+    -> a 'Never
+      -> a 'Less
+        -> a 'Equal
+          -> a 'Lequal
+            -> a 'Greater
+              -> a 'Notequal
+                -> a 'Gequal -> a 'Always -> forall (b :: ComparisonFunction) -> a b
+case'ComparisonFunction
+  = \a b c d e f g h i j -> <<case function of a type with 0 parameters>>
+
+case'CullMode
+  :: forall (a :: CullMode -> Type)
+    -> a 'CullFront -> a 'CullBack -> a 'CullNone -> forall (b :: CullMode) -> a b
+case'CullMode = \a b c d e -> <<case function of a type with 0 parameters>>
+
+case'EdgeMode
+  :: forall (a :: EdgeMode -> Type)
+    -> a 'Repeat
+      -> a 'MirroredRepeat -> a 'ClampToEdge -> forall (b :: EdgeMode) -> a b
+case'EdgeMode = \a b c d e -> <<case function of a type with 0 parameters>>
+
+case'Filter
+  :: forall (a :: Filter -> Type)
+    -> a 'PointFilter -> a 'LinearFilter -> forall (b :: Filter) -> a b
+case'Filter = \a b c d -> <<case function of a type with 0 parameters>>
+
+case'FragmentOperation
+  :: forall (a :: forall (b :: ImageKind) -> FragmentOperation b -> Type)
+    -> (forall c (d :: Nat) (e :: CW (Num c))
+        . forall (f :: Blending c) (g :: VecScalar d Bool)
+          -> a ('Color (VecScalar d c)) ('ColorOp c d e f g))
+      -> (forall (h :: ComparisonFunction) (i :: Bool) -> a 'Depth ('DepthOp h i))
+        -> (forall (j :: StencilTests) (k :: StencilOps) (l :: StencilOps)
+            -> a 'Stencil ('StencilOp j k l))
+          -> forall (m :: ImageKind) . forall (n :: FragmentOperation m) -> a m n
+case'FragmentOperation
+  = \a b c d e f -> <<case function of a type with 0 parameters>>
+
+case'FrameBuffer
+  :: forall (a :: Nat) (b :: [ImageKind])
+    . forall (c :: FrameBuffer a b -> Type) (d :: FrameBuffer a b) -> c d
+case'FrameBuffer = \_ _ a b -> <<case function of a type with 2 parameters>>
+
+case'Image
+  :: forall (a :: Nat) (b :: ImageKind)
+    . forall (c :: Image a b -> Type) (d :: Image a b) -> c d
+case'Image = \_ _ a b -> <<case function of a type with 2 parameters>>
+
+case'ImageKind
+  :: forall (a :: ImageKind -> Type)
+    -> (forall b -> a ('Color b))
+      -> a 'Depth -> a 'Stencil -> forall (c :: ImageKind) -> a c
+case'ImageKind = \a b c d e -> <<case function of a type with 0 parameters>>
+
+case'Interpolated
+  :: forall a
+    . forall (b :: Interpolated a -> Type)
+      -> (forall (c :: CW (Floating a)) . b ('Smooth c))
+        -> (forall (d :: CW (Floating a)) . b ('NoPerspective d))
+          -> b 'Flat -> forall (e :: Interpolated a) -> b e
+case'Interpolated
+  = \_ a b c d e -> <<case function of a type with 1 parameters>>
+
 case'LogicOperation
   :: forall (a :: LogicOperation -> Type)
     -> a 'Clear
@@ -1657,81 +2628,63 @@ case'LogicOperation
                           -> a 'OrReverse
                             -> a 'CopyInverted
                               -> a 'OrInverted -> a 'Nand -> a 'Set -> forall (b :: LogicOperation) -> a b
-match'LogicOperation
-  :: forall (a :: Type -> Type) -> a LogicOperation -> forall b -> a b -> a b
-'StencilOperation :: Type
-OpZero :: StencilOperation
-OpKeep :: StencilOperation
-OpReplace :: StencilOperation
-OpIncr :: StencilOperation
-OpIncrWrap :: StencilOperation
-OpDecr :: StencilOperation
-OpDecrWrap :: StencilOperation
-OpInvert :: StencilOperation
-case'StencilOperation
-  :: forall (a :: StencilOperation -> Type)
-    -> a 'OpZero
-      -> a 'OpKeep
-        -> a 'OpReplace
-          -> a 'OpIncr
-            -> a 'OpIncrWrap
-              -> a 'OpDecr
-                -> a 'OpDecrWrap -> a 'OpInvert -> forall (b :: StencilOperation) -> a b
-match'StencilOperation
-  :: forall (a :: Type -> Type) -> a StencilOperation -> forall b -> a b -> a b
-'ComparisonFunction :: Type
-Never :: ComparisonFunction
-Less :: ComparisonFunction
-Equal :: ComparisonFunction
-Lequal :: ComparisonFunction
-Greater :: ComparisonFunction
-Notequal :: ComparisonFunction
-Gequal :: ComparisonFunction
-Always :: ComparisonFunction
-case'ComparisonFunction
-  :: forall (a :: ComparisonFunction -> Type)
-    -> a 'Never
-      -> a 'Less
-        -> a 'Equal
-          -> a 'Lequal
-            -> a 'Greater
-              -> a 'Notequal
-                -> a 'Gequal -> a 'Always -> forall (b :: ComparisonFunction) -> a b
-match'ComparisonFunction
-  :: forall (a :: Type -> Type) -> a ComparisonFunction -> forall b -> a b -> a b
-'ProvokingVertex :: Type
-LastVertex :: ProvokingVertex
-FirstVertex :: ProvokingVertex
-case'ProvokingVertex
-  :: forall (a :: ProvokingVertex -> Type)
-    -> a 'LastVertex -> a 'FirstVertex -> forall (b :: ProvokingVertex) -> a b
-match'ProvokingVertex
-  :: forall (a :: Type -> Type) -> a ProvokingVertex -> forall b -> a b -> a b
-'CullMode :: Type
-CullFront :: CullMode
-CullBack :: CullMode
-CullNone :: CullMode
-case'CullMode
-  :: forall (a :: CullMode -> Type)
-    -> a 'CullFront -> a 'CullBack -> a 'CullNone -> forall (b :: CullMode) -> a b
-match'CullMode
-  :: forall (a :: Type -> Type) -> a CullMode -> forall b -> a b -> a b
-'PointSize :: Type -> Type
-PointSize :: forall a . Float -> PointSize a
-ProgramPointSize :: forall a . (a -> Float) -> PointSize a
+case'LogicOperation
+  = \a b c d e f g h i j k l m n o p q r
+    -> <<case function of a type with 0 parameters>>
+
+case'Mat
+  :: forall (a :: forall (b :: Nat) (c :: Nat) d -> Mat b c d -> Type)
+    -> (forall (e :: Vec 2 Float) (f :: Vec 2 Float) -> a 2 2 Float ('M22F e f))
+      -> (forall (g :: Vec 3 Float) (h :: Vec 3 Float) -> a 3 2 Float ('M32F g h))
+        -> (forall (i :: Vec 4 Float) (j :: Vec 4 Float) -> a 4 2 Float ('M42F i j))
+          -> (forall (k :: Vec 2 Float) (l :: Vec 2 Float) (m :: Vec 2 Float)
+              -> a 2 3 Float ('M23F k l m))
+            -> (forall (n :: Vec 3 Float) (o :: Vec 3 Float) (p :: Vec 3 Float)
+                -> a 3 3 Float ('M33F n o p))
+              -> (forall (q :: Vec 4 Float) (r :: Vec 4 Float) (s :: Vec 4 Float)
+                  -> a 4 3 Float ('M43F q r s))
+                -> (forall (t :: Vec 2 Float)
+                      (u :: Vec 2 Float) (v :: Vec 2 Float) (w :: Vec 2 Float)
+                    -> a 2 4 Float ('M24F t u v w))
+                  -> (forall (x :: Vec 3 Float)
+                        (y :: Vec 3 Float) (z :: Vec 3 Float) (a' :: Vec 3 Float)
+                      -> a 3 4 Float ('M34F x y z a'))
+                    -> (forall (b' :: Vec 4 Float)
+                          (c' :: Vec 4 Float) (d' :: Vec 4 Float) (e' :: Vec 4 Float)
+                        -> a 4 4 Float ('M44F b' c' d' e'))
+                      -> forall (f' :: Nat) (g' :: Nat) h'
+                        . forall (i' :: Mat f' g' h') -> a f' g' h' i'
+case'Mat
+  = \a b c d e f g h i j k l m n -> <<case function of a type with 0 parameters>>
+
+case'Maybe
+  :: forall a
+    . forall (b :: Maybe a -> Type)
+      -> b 'Nothing
+        -> (forall (c :: a) -> b ('Just c)) -> forall (d :: Maybe a) -> b d
+case'Maybe = \_ a b c d -> <<case function of a type with 1 parameters>>
+
+case'Output
+  :: forall (a :: Output -> Type)
+    -> (forall (b :: Nat) (c :: [ImageKind])
+        . forall (d :: FrameBuffer b c) -> a ('ScreenOut b c d))
+      -> forall (e :: Output) -> a e
+case'Output = \a b c -> <<case function of a type with 0 parameters>>
+
 case'PointSize
   :: forall a
     . forall (b :: PointSize a -> Type)
       -> (forall (c :: Float) -> b ('PointSize c))
         -> (forall (d :: a -> Float) -> b ('ProgramPointSize d))
           -> forall (e :: PointSize a) -> b e
-match'PointSize
-  :: forall (a :: Type -> Type)
-    -> (forall b -> a (PointSize b)) -> forall c -> a c -> a c
-'PolygonMode :: Type -> Type
-PolygonFill :: forall a . PolygonMode a
-PolygonPoint :: forall a . PointSize a -> PolygonMode a
-PolygonLine :: forall a . Float -> PolygonMode a
+case'PointSize = \_ a b c d -> <<case function of a type with 1 parameters>>
+
+case'PointSpriteCoordOrigin
+  :: forall (a :: PointSpriteCoordOrigin -> Type)
+    -> a 'LowerLeft -> a 'UpperLeft -> forall (b :: PointSpriteCoordOrigin) -> a b
+case'PointSpriteCoordOrigin
+  = \a b c d -> <<case function of a type with 0 parameters>>
+
 case'PolygonMode
   :: forall a
     . forall (b :: PolygonMode a -> Type)
@@ -1739,40 +2692,39 @@ case'PolygonMode
         -> (forall (c :: PointSize a) -> b ('PolygonPoint c))
           -> (forall (d :: Float) -> b ('PolygonLine d))
             -> forall (e :: PolygonMode a) -> b e
-match'PolygonMode
-  :: forall (a :: Type -> Type)
-    -> (forall b -> a (PolygonMode b)) -> forall c -> a c -> a c
-'PolygonOffset :: Type
-NoOffset :: PolygonOffset
-Offset :: Float -> Float -> PolygonOffset
+case'PolygonMode = \_ a b c d e -> <<case function of a type with 1 parameters>>
+
 case'PolygonOffset
   :: forall (a :: PolygonOffset -> Type)
     -> a 'NoOffset
       -> (forall (b :: Float) (c :: Float) -> a ('Offset b c))
         -> forall (d :: PolygonOffset) -> a d
-match'PolygonOffset
-  :: forall (a :: Type -> Type) -> a PolygonOffset -> forall b -> a b -> a b
-'PointSpriteCoordOrigin :: Type
-LowerLeft :: PointSpriteCoordOrigin
-UpperLeft :: PointSpriteCoordOrigin
-case'PointSpriteCoordOrigin
-  :: forall (a :: PointSpriteCoordOrigin -> Type)
-    -> a 'LowerLeft -> a 'UpperLeft -> forall (b :: PointSpriteCoordOrigin) -> a b
-match'PointSpriteCoordOrigin
-  :: forall (a :: Type -> Type)
-    -> a PointSpriteCoordOrigin -> forall b -> a b -> a b
-primTexture :: () -> Vec 2 Float -> Vec 4 Float
-Uniform :: forall a . String -> a
-'RasterContext :: Type -> PrimitiveType -> Type
-TriangleCtx
-  :: forall a
-    . CullMode
-      -> PolygonMode a
-        -> PolygonOffset -> ProvokingVertex -> RasterContext a 'Triangle
-PointCtx
+case'PolygonOffset = \a b c d -> <<case function of a type with 0 parameters>>
+
+case'Primitive
   :: forall a
-    . PointSize a -> Float -> PointSpriteCoordOrigin -> RasterContext a 'Point
-LineCtx :: forall a . Float -> ProvokingVertex -> RasterContext a 'Line
+    . forall (b :: forall (c :: PrimitiveType) -> Primitive a c -> Type)
+      -> (forall (d :: a) -> b 'Point ('PrimPoint d))
+        -> (forall (e :: a) (f :: a) -> b 'Line ('PrimLine e f))
+          -> (forall (g :: a) (h :: a) (i :: a) -> b 'Triangle ('PrimTriangle g h i))
+            -> forall (j :: PrimitiveType) . forall (k :: Primitive a j) -> b j k
+case'Primitive = \_ a b c d e f -> <<case function of a type with 1 parameters>>
+
+case'PrimitiveType
+  :: forall (a :: PrimitiveType -> Type)
+    -> a 'Triangle
+      -> a 'Line
+        -> a 'Point
+          -> a 'TriangleAdjacency
+            -> a 'LineAdjacency -> forall (b :: PrimitiveType) -> a b
+case'PrimitiveType
+  = \a b c d e f g -> <<case function of a type with 0 parameters>>
+
+case'ProvokingVertex
+  :: forall (a :: ProvokingVertex -> Type)
+    -> a 'LastVertex -> a 'FirstVertex -> forall (b :: ProvokingVertex) -> a b
+case'ProvokingVertex = \a b c d -> <<case function of a type with 0 parameters>>
+
 case'RasterContext
   :: forall a
     . forall (b :: forall (c :: PrimitiveType) -> RasterContext a c -> Type)
@@ -1783,73 +2735,477 @@ case'RasterContext
             -> b 'Point ('PointCtx h i j))
           -> (forall (k :: Float) (l :: ProvokingVertex) -> b 'Line ('LineCtx k l))
             -> forall (m :: PrimitiveType) . forall (n :: RasterContext a m) -> b m n
-match'RasterContext
-  :: forall (a :: Type -> Type)
-    -> (forall b (c :: PrimitiveType) -> a (RasterContext b c))
-      -> forall d -> a d -> a d
-'Blending :: Type -> Type
-NoBlending :: forall a . Blending a
-BlendLogicOp :: forall a . Integral a => LogicOperation -> Blending a
-Blend
-  :: (BlendEquation, BlendEquation)
-    -> ((BlendingFactor, BlendingFactor), (BlendingFactor, BlendingFactor))
-      -> Vec 4 Float -> Blending Float
-case'Blending
-  :: forall (a :: forall b -> Blending b -> Type)
-    -> (forall c . a c ('NoBlending c))
-      -> (forall d (e :: CW (Integral d))
-          . forall (f :: LogicOperation) -> a d ('BlendLogicOp d e f))
-        -> (forall (g :: (BlendEquation, BlendEquation))
-              (h :: ((BlendingFactor, BlendingFactor), (BlendingFactor, BlendingFactor)))
-                (i :: Vec 4 Float)
-            -> a Float ('Blend g h i))
-          -> forall j . forall (k :: Blending j) -> a j k
-match'Blending
-  :: forall (a :: Type -> Type)
-    -> (forall b -> a (Blending b)) -> forall c -> a c -> a c
-'StencilTests :: Type
+case'RasterContext
+  = \_ a b c d e f -> <<case function of a type with 1 parameters>>
+
+case'Sampler
+  :: forall (a :: Sampler -> Type)
+    -> (forall (b :: Filter) (c :: EdgeMode) (d :: Texture) -> a ('Sampler b c d))
+      -> forall (e :: Sampler) -> a e
+case'Sampler = \a b c -> <<case function of a type with 0 parameters>>
+
+case'SimpleFragment
+  :: forall a
+    . forall (b :: SimpleFragment a -> Type)
+      -> (forall (c :: Vec 3 Float) (d :: a) -> b ('SimpleFragment c d))
+        -> forall (e :: SimpleFragment a) -> b e
+case'SimpleFragment = \_ a b c -> <<case function of a type with 1 parameters>>
+
+case'StencilOperation
+  :: forall (a :: StencilOperation -> Type)
+    -> a 'OpZero
+      -> a 'OpKeep
+        -> a 'OpReplace
+          -> a 'OpIncr
+            -> a 'OpIncrWrap
+              -> a 'OpDecr
+                -> a 'OpDecrWrap -> a 'OpInvert -> forall (b :: StencilOperation) -> a b
+case'StencilOperation
+  = \a b c d e f g h i j -> <<case function of a type with 0 parameters>>
+
+case'StencilOps :: forall (a :: StencilOps -> Type) (b :: StencilOps) -> a b
+case'StencilOps = \a b -> <<case function of a type with 0 parameters>>
+
 case'StencilTests
   :: forall (a :: StencilTests -> Type) (b :: StencilTests) -> a b
-match'StencilTests
-  :: forall (a :: Type -> Type) -> a StencilTests -> forall b -> a b -> a b
-'StencilOps :: Type
-case'StencilOps :: forall (a :: StencilOps -> Type) (b :: StencilOps) -> a b
-match'StencilOps
-  :: forall (a :: Type -> Type) -> a StencilOps -> forall b -> a b -> a b
-'FragmentOperation :: ImageKind -> Type
-ColorOp
+case'StencilTests = \a b -> <<case function of a type with 0 parameters>>
+
+case'Swizz
+  :: forall (a :: Swizz -> Type)
+    -> a 'Sx -> a 'Sy -> a 'Sz -> a 'Sw -> forall (b :: Swizz) -> a b
+case'Swizz = \a b c d e f -> <<case function of a type with 0 parameters>>
+
+case'Texture
+  :: forall (a :: Texture -> Type)
+    -> (forall (b :: String) -> a ('Texture2DSlot b))
+      -> (forall (c :: Vec 2 Int) (d :: Image 1 ('Color (Vec 4 Float)))
+          -> a ('Texture2D c d))
+        -> forall (e :: Texture) -> a e
+case'Texture = \a b c d -> <<case function of a type with 0 parameters>>
+
+case'VecS
+  :: forall a
+    . forall (b :: forall (c :: Nat) -> VecS a c -> Type)
+      -> (forall (d :: a) (e :: a) -> b 2 ('V2 d e))
+        -> (forall (f :: a) (g :: a) (h :: a) -> b 3 ('V3 f g h))
+          -> (forall (i :: a) (j :: a) (k :: a) (l :: a) -> b 4 ('V4 i j k l))
+            -> forall (m :: Nat) . forall (n :: VecS a m) -> b m n
+case'VecS = \_ a b c d e f -> <<case function of a type with 1 parameters>>
+
+case'Vector
+  :: forall (a :: Nat) b
+    . forall (c :: Vector a b -> Type) (d :: Vector a b) -> c d
+case'Vector = \_ _ a b -> <<case function of a type with 2 parameters>>
+
+concat :: forall a . [[a]] -> [a]
+concat = \a -> _rhs (foldr [a] [a] ((++) a) [])
+
+concatMap :: forall a b . (a -> [b]) -> [a] -> [b]
+concatMap = \a b c d -> _rhs (foldr [b] [b] ((++) b) [] (map a [b] c d))
+
+customizeDepth
+  :: forall a (b :: Nat) . (a -> Float) -> Fragment b a -> Fragment b a
+customizeDepth = \a b c d -> <<builtin>>
+
+customizeDepths
   :: forall a (b :: Nat)
-    . Num a
-      => Blending a -> VecScalar b Bool -> FragmentOperation ('Color (VecScalar b a))
-DepthOp :: ComparisonFunction -> Bool -> FragmentOperation 'Depth
-StencilOp
-  :: StencilTests -> StencilOps -> StencilOps -> FragmentOperation 'Stencil
-case'FragmentOperation
-  :: forall (a :: forall (b :: ImageKind) -> FragmentOperation b -> Type)
-    -> (forall c (d :: Nat) (e :: CW (Num c))
-        . forall (f :: Blending c) (g :: VecScalar d Bool)
-          -> a ('Color (VecScalar d c)) ('ColorOp c d e f g))
-      -> (forall (h :: ComparisonFunction) (i :: Bool) -> a 'Depth ('DepthOp h i))
-        -> (forall (j :: StencilTests) (k :: StencilOps) (l :: StencilOps)
-            -> a 'Stencil ('StencilOp j k l))
-          -> forall (m :: ImageKind) . forall (n :: FragmentOperation m) -> a m n
+    . (a -> Float)
+      -> [Vector b (Maybe (SimpleFragment a))]
+        -> [Vector b (Maybe (SimpleFragment a))]
+customizeDepths
+  = \a b c -> _rhs
+    (map
+      ('Vector b ('Maybe ('SimpleFragment a)))
+      ('Vector b ('Maybe ('SimpleFragment a)))
+      \d -> customizeDepth a b c d)
+
+definedVec :: forall a (b :: Nat) . Vec b a -> Bool
+definedVec
+  = \_ a b -> case'VecS
+    (\_ _ -> 'Bool)
+    (\_ _ -> _rhs True)
+    (\_ _ _ -> _rhs True)
+    (\_ _ _ _ -> _rhs True)
+    a
+    b
+
+emptyColorImage
+  :: forall (a :: Nat) b c . (Num b, c ~ VecScalar a b) => c -> Image 1 ('Color c)
+emptyColorImage = _rhs \a b c d e f -> ColorImage 1 a b c d e f
+
+emptyDepthImage :: Float -> Image 1 'Depth
+emptyDepthImage = _rhs \a -> DepthImage 1 a
+
+fetch
+  :: forall (a :: PrimitiveType) (b :: [Type])
+    . String -> HList b -> PrimitiveStream a (HList b)
+fetch = \a b c d -> <<builtin>>
+
+fetchArrays
+  :: forall (a :: PrimitiveType) (b :: [Type]) (c :: [Type])
+    . (b ~ (map Type Type ListElem c :: [Type]))
+      => HList c -> PrimitiveStream a (HList b)
+fetchArrays = \a b c d e -> <<builtin>>
+
+fetchStream
+  :: forall (a :: PrimitiveType) (b :: [Type])
+    . String
+      -> forall (c :: [String])
+        -> (len String c ~ (len Type b :: Int)) => PrimitiveStream a (HList b)
+fetchStream = \a b c d e -> <<builtin>>
+
+filterFragment
+  :: forall a (b :: Nat) . (a -> Bool) -> Fragment b a -> Fragment b a
+filterFragment = \a b c d -> <<builtin>>
+
+filterFragments
+  :: forall a (b :: Nat)
+    . (a -> Bool)
+      -> [Vector b (Maybe (SimpleFragment a))]
+        -> [Vector b (Maybe (SimpleFragment a))]
+filterFragments
+  = \a b c -> _rhs
+    (map
+      ('Vector b ('Maybe ('SimpleFragment a)))
+      ('Vector b ('Maybe ('SimpleFragment a)))
+      \d -> filterFragment a b c d)
+
+foldr :: forall a b . (b -> a -> a) -> a -> [b] -> a
+foldr
+  = \a b -> primFix
+    ((b -> a -> a) -> a -> [b] -> a)
+    \c d e f -> case'List (\_ -> a) (_rhs e) (\g h -> _rhs (d g (c d e h))) f
+
+head :: forall a . [a] -> a
+head = \a b -> case'List (\_ -> a) (_rhs (undefined a)) (\c _ -> _rhs c) b
+
+id :: forall a . a -> a
+id = \_ a -> _rhs a
+
+imageFrame
+  :: forall (a :: [Type])
+    . sameLayerCounts a
+      => HList a
+        -> FrameBuffer (ImageLC (head Type a)) (map Type ImageKind GetImageKind a)
+imageFrame = _rhs \a b c -> FrameBuffer a b c
+
+imageType :: ImageKind -> Type
+imageType
+  = \a -> case'ImageKind (\_ -> Type) (\b -> _rhs b) (_rhs 'Float) (_rhs 'Int) a
+
+imageType' :: [ImageKind] -> [Type]
+imageType'
+  = \a -> case'List
+    (\_ -> [Type])
+    (_rhs (map 'ImageKind Type imageType a))
+    (\b c -> case'ImageKind
+      (\_ -> [Type])
+      (\_ -> _rhs (map 'ImageKind Type imageType a))
+      (_rhs (map 'ImageKind Type imageType c))
+      (_rhs (map 'ImageKind Type imageType a))
+      b)
+    a
+
+len :: forall a . [a] -> Int
+len
+  = \a -> primFix
+    ([a] -> 'Int)
+    \b c -> case'List (\_ -> 'Int) (_rhs 0) (\_ d -> _rhs (primAddInt 1 (b d))) c
+
+map :: forall a b . (a -> b) -> [a] -> [b]
+map
+  = \a b -> primFix
+    ((a -> b) -> [a] -> [b])
+    \c d e -> case'List (\_ -> [b]) (_rhs []) (\f g -> _rhs (d f : c d g)) e
+
+mapFragment :: forall a b (c :: Nat) . (a -> b) -> Fragment c a -> Fragment c b
+mapFragment = \a b c d e -> <<builtin>>
+
+mapFragments
+  :: forall a b (c :: Nat)
+    . (a -> b)
+      -> [Vector c (Maybe (SimpleFragment a))]
+        -> [Vector c (Maybe (SimpleFragment b))]
+mapFragments
+  = \a b c d -> _rhs
+    (map
+      ('Vector c ('Maybe ('SimpleFragment a)))
+      ('Vector c ('Maybe ('SimpleFragment b)))
+      \e -> mapFragment a b c d e)
+
+mapPrimitive
+  :: forall a b (c :: PrimitiveType) . (a -> b) -> Primitive a c -> Primitive b c
+mapPrimitive = \a b c d e -> <<builtin>>
+
+mapPrimitives
+  :: forall a b (c :: PrimitiveType)
+    . (a -> b) -> [Primitive a c] -> [Primitive b c]
+mapPrimitives
+  = \a b c d -> _rhs
+    (map ('Primitive a c) ('Primitive b c) \e -> mapPrimitive a b c d e)
+
+mapVec :: forall a b (c :: Nat) . (a -> b) -> VecS a c -> VecS b c
+mapVec
+  = \_ a b c d -> case'VecS
+    (\e _ -> 'VecS a e)
+    (\f g -> _rhs (V2 (c f) (c g)))
+    (\h i j -> _rhs (V3 (c h) (c i) (c j)))
+    (\k l m n -> _rhs (V4 (c k) (c l) (c m) (c n)))
+    b
+    d
+
+match'BlendEquation
+  :: forall (a :: Type -> Type) -> a BlendEquation -> forall b -> a b -> a b
+match'BlendEquation = \a b c d -> <<type case function>>
+
+match'Blending
+  :: forall (a :: Type -> Type)
+    -> (forall b -> a (Blending b)) -> forall c -> a c -> a c
+match'Blending = \a b c d -> <<type case function>>
+
+match'BlendingFactor
+  :: forall (a :: Type -> Type) -> a BlendingFactor -> forall b -> a b -> a b
+match'BlendingFactor = \a b c d -> <<type case function>>
+
+match'ComparisonFunction
+  :: forall (a :: Type -> Type) -> a ComparisonFunction -> forall b -> a b -> a b
+match'ComparisonFunction = \a b c d -> <<type case function>>
+
+match'CullMode
+  :: forall (a :: Type -> Type) -> a CullMode -> forall b -> a b -> a b
+match'CullMode = \a b c d -> <<type case function>>
+
+match'EdgeMode
+  :: forall (a :: Type -> Type) -> a EdgeMode -> forall b -> a b -> a b
+match'EdgeMode = \a b c d -> <<type case function>>
+
+match'Filter :: forall (a :: Type -> Type) -> a Filter -> forall b -> a b -> a b
+match'Filter = \a b c d -> <<type case function>>
+
 match'FragmentOperation
   :: forall (a :: Type -> Type)
     -> (forall (b :: ImageKind) -> a (FragmentOperation b))
       -> forall c -> a c -> a c
-'Interpolated :: Type -> Type
-Smooth :: forall a . Floating a => Interpolated a
-NoPerspective :: forall a . Floating a => Interpolated a
-Flat :: forall a . Interpolated a
-case'Interpolated
-  :: forall a
-    . forall (b :: Interpolated a -> Type)
-      -> (forall (c :: CW (Floating a)) . b ('Smooth c))
-        -> (forall (d :: CW (Floating a)) . b ('NoPerspective d))
-          -> b 'Flat -> forall (e :: Interpolated a) -> b e
+match'FragmentOperation = \a b c d -> <<type case function>>
+
+match'FrameBuffer
+  :: forall (a :: Type -> Type)
+    -> (forall (b :: Nat) (c :: [ImageKind]) -> a (FrameBuffer b c))
+      -> forall d -> a d -> a d
+match'FrameBuffer = \a b c d -> <<type case function>>
+
+match'Image
+  :: forall (a :: Type -> Type)
+    -> (forall (b :: Nat) (c :: ImageKind) -> a (Image b c))
+      -> forall d -> a d -> a d
+match'Image = \a b c d -> <<type case function>>
+
+match'ImageKind
+  :: forall (a :: Type -> Type) -> a ImageKind -> forall b -> a b -> a b
+match'ImageKind = \a b c d -> <<type case function>>
+
 match'Interpolated
   :: forall (a :: Type -> Type)
     -> (forall b -> a (Interpolated b)) -> forall c -> a c -> a c
+match'Interpolated = \a b c d -> <<type case function>>
+
+match'LogicOperation
+  :: forall (a :: Type -> Type) -> a LogicOperation -> forall b -> a b -> a b
+match'LogicOperation = \a b c d -> <<type case function>>
+
+match'Mat
+  :: forall (a :: Type -> Type)
+    -> (forall (b :: Nat) (c :: Nat) d -> a (Mat b c d)) -> forall e -> a e -> a e
+match'Mat = \a b c d -> <<type case function>>
+
+match'Maybe
+  :: forall (a :: Type -> Type)
+    -> (forall b -> a (Maybe b)) -> forall c -> a c -> a c
+match'Maybe = \a b c d -> <<type case function>>
+
+match'Output :: forall (a :: Type -> Type) -> a Output -> forall b -> a b -> a b
+match'Output = \a b c d -> <<type case function>>
+
+match'PointSize
+  :: forall (a :: Type -> Type)
+    -> (forall b -> a (PointSize b)) -> forall c -> a c -> a c
+match'PointSize = \a b c d -> <<type case function>>
+
+match'PointSpriteCoordOrigin
+  :: forall (a :: Type -> Type)
+    -> a PointSpriteCoordOrigin -> forall b -> a b -> a b
+match'PointSpriteCoordOrigin = \a b c d -> <<type case function>>
+
+match'PolygonMode
+  :: forall (a :: Type -> Type)
+    -> (forall b -> a (PolygonMode b)) -> forall c -> a c -> a c
+match'PolygonMode = \a b c d -> <<type case function>>
+
+match'PolygonOffset
+  :: forall (a :: Type -> Type) -> a PolygonOffset -> forall b -> a b -> a b
+match'PolygonOffset = \a b c d -> <<type case function>>
+
+match'Primitive
+  :: forall (a :: Type -> Type)
+    -> (forall b (c :: PrimitiveType) -> a (Primitive b c))
+      -> forall d -> a d -> a d
+match'Primitive = \a b c d -> <<type case function>>
+
+match'PrimitiveType
+  :: forall (a :: Type -> Type) -> a PrimitiveType -> forall b -> a b -> a b
+match'PrimitiveType = \a b c d -> <<type case function>>
+
+match'ProvokingVertex
+  :: forall (a :: Type -> Type) -> a ProvokingVertex -> forall b -> a b -> a b
+match'ProvokingVertex = \a b c d -> <<type case function>>
+
+match'RasterContext
+  :: forall (a :: Type -> Type)
+    -> (forall b (c :: PrimitiveType) -> a (RasterContext b c))
+      -> forall d -> a d -> a d
+match'RasterContext = \a b c d -> <<type case function>>
+
+match'Sampler
+  :: forall (a :: Type -> Type) -> a Sampler -> forall b -> a b -> a b
+match'Sampler = \a b c d -> <<type case function>>
+
+match'SimpleFragment
+  :: forall (a :: Type -> Type)
+    -> (forall b -> a (SimpleFragment b)) -> forall c -> a c -> a c
+match'SimpleFragment = \a b c d -> <<type case function>>
+
+match'StencilOperation
+  :: forall (a :: Type -> Type) -> a StencilOperation -> forall b -> a b -> a b
+match'StencilOperation = \a b c d -> <<type case function>>
+
+match'StencilOps
+  :: forall (a :: Type -> Type) -> a StencilOps -> forall b -> a b -> a b
+match'StencilOps = \a b c d -> <<type case function>>
+
+match'StencilTests
+  :: forall (a :: Type -> Type) -> a StencilTests -> forall b -> a b -> a b
+match'StencilTests = \a b c d -> <<type case function>>
+
+match'Swizz :: forall (a :: Type -> Type) -> a Swizz -> forall b -> a b -> a b
+match'Swizz = \a b c d -> <<type case function>>
+
+match'Texture
+  :: forall (a :: Type -> Type) -> a Texture -> forall b -> a b -> a b
+match'Texture = \a b c d -> <<type case function>>
+
+match'VecS
+  :: forall (a :: Type -> Type)
+    -> (forall b (c :: Nat) -> a (VecS b c)) -> forall d -> a d -> a d
+match'VecS = \a b c d -> <<type case function>>
+
+match'Vector
+  :: forall (a :: Type -> Type)
+    -> (forall (b :: Nat) c -> a (Vector b c)) -> forall d -> a d -> a d
+match'Vector = \a b c d -> <<type case function>>
+
+one :: forall a . Component a => a
+one
+  = \a _ -> match'Int
+    (\b -> b)
+    (_rhs 1)
+    a
+    (match'Word
+      (\c -> c)
+      (_rhs (primIntToWord 1))
+      a
+      (match'Float
+        (\d -> d)
+        (_rhs 1.0)
+        a
+        (match'VecS
+          (\e -> e)
+          (\f g -> match'Float
+            (\h -> 'VecS h g)
+            (case'Nat
+              (\i -> 'VecS 'Float i)
+              (_rhs (undefined ('VecS 'Float 0)))
+              (\j -> case'Nat
+                (\k -> 'VecS 'Float (Succ k))
+                (_rhs (undefined ('VecS 'Float 1)))
+                (\l -> case'Nat
+                  (\m -> 'VecS 'Float (Succ (Succ m)))
+                  (_rhs (V2 1.0 1.0))
+                  (\n -> case'Nat
+                    (\o -> 'VecS 'Float (Succ (Succ (Succ o))))
+                    (_rhs (V3 1.0 1.0 1.0))
+                    (\p -> case'Nat
+                      (\q -> 'VecS 'Float (Succ (Succ (Succ (Succ q)))))
+                      (_rhs (V4 1.0 1.0 1.0 1.0))
+                      (\r -> _rhs (undefined ('VecS 'Float (Succ (Succ (Succ (Succ (Succ r))))))))
+                      p)
+                    n)
+                  l)
+                j)
+              g)
+            f
+            (match'Bool
+              (\s -> 'VecS s g)
+              (case'Nat
+                (\t -> 'VecS 'Bool t)
+                (_rhs (undefined ('VecS 'Bool 0)))
+                (\u -> case'Nat
+                  (\v -> 'VecS 'Bool (Succ v))
+                  (_rhs (undefined ('VecS 'Bool 1)))
+                  (\w -> case'Nat
+                    (\x -> 'VecS 'Bool (Succ (Succ x)))
+                    (_rhs (V2 True True))
+                    (\y -> case'Nat
+                      (\z -> 'VecS 'Bool (Succ (Succ (Succ z))))
+                      (_rhs (V3 True True True))
+                      (\a' -> case'Nat
+                        (\b' -> 'VecS 'Bool (Succ (Succ (Succ (Succ b')))))
+                        (_rhs (V4 True True True True))
+                        (\c' -> _rhs (undefined ('VecS 'Bool (Succ (Succ (Succ (Succ (Succ c'))))))))
+                        a')
+                      y)
+                    w)
+                  u)
+                g)
+              f
+              (_rhs (undefined ('VecS f g)))))
+          a
+          (match'Bool (\d' -> d') (_rhs True) a (_rhs (undefined a))))))
+
+overlay
+  :: forall (a :: Nat) (b :: [Type])
+    . FrameBuffer a (map Type ImageKind FragmentOperationKind b)
+      -> (HList b
+        , [Fragment
+          a
+          (HList (imageType' (map Type ImageKind FragmentOperationKind b)))])
+        -> FrameBuffer a (map Type ImageKind FragmentOperationKind b)
+overlay
+  = \a b c d -> hlistConsCase
+    ('HList b)
+    [['Vector
+      a
+      ('Maybe
+        ('SimpleFragment
+          ('HList (imageType' (map Type 'ImageKind 'FragmentOperationKind b)))))]]
+    ('FrameBuffer a (map Type 'ImageKind 'FragmentOperationKind b))
+    (\e f -> hlistConsCase
+      ['Vector
+        a
+        ('Maybe
+          ('SimpleFragment
+            ('HList (imageType' (map Type 'ImageKind 'FragmentOperationKind b)))))]
+      []
+      ('FrameBuffer a (map Type 'ImageKind 'FragmentOperationKind b))
+      (\g h -> hlistNilCase
+        ('FrameBuffer a (map Type 'ImageKind 'FragmentOperationKind b))
+        (_rhs (Accumulate (map Type 'ImageKind 'FragmentOperationKind b) a b TT e g c))
+        h)
+      f)
+    d
+
+primTexture :: () -> Vec 2 Float -> Vec 4 Float
+primTexture = \a b -> <<builtin>>
+
 rasterizePrimitive
   :: forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (d :: PrimitiveType)
     . (map Type Type Interpolated a ~ (b :: [Type])
@@ -1857,108 +3213,150 @@ rasterizePrimitive
       => HList b
         -> RasterContext (HList c) d
           -> Primitive (HList c) d -> FragmentStream 1 (HList a)
+rasterizePrimitive = \a b c d e f g h i -> <<builtin>>
+
 rasterizePrimitives
   :: forall (a :: [Type]) (b :: PrimitiveType)
     . RasterContext (HList (Vec 4 Float : a)) b
       -> HList (map Type Type Interpolated a)
         -> [Primitive (HList (Vec 4 Float : a)) b]
           -> [Vector 1 (Maybe (SimpleFragment (HList a)))]
-'ImageLC :: Type -> Nat
-allSame :: forall a . [a] -> Constraint
-sameLayerCounts :: [Type] -> Constraint
-'FrameBuffer :: Nat -> [ImageKind] -> Type
-case'FrameBuffer
-  :: forall (a :: Nat) (b :: [ImageKind])
-    . forall (c :: FrameBuffer a b -> Type) (d :: FrameBuffer a b) -> c d
-match'FrameBuffer
-  :: forall (a :: Type -> Type)
-    -> (forall (b :: Nat) (c :: [ImageKind]) -> a (FrameBuffer b c))
-      -> forall d -> a d -> a d
-imageType' :: [ImageKind] -> [Type]
-'FragmentOperationKind :: Type -> ImageKind
-Accumulate
-  :: forall (a :: [ImageKind]) (b :: Nat) (c :: [Type])
-    . (a ~ (map Type ImageKind FragmentOperationKind c :: [ImageKind]))
-      => HList c
-        -> FragmentStream b (HList (imageType' a)) -> FrameBuffer b a -> FrameBuffer b a
-accumulateWith :: forall a b . a -> b -> (a, b)
-overlay
-  :: forall (a :: Nat) (b :: [Type])
-    . FrameBuffer a (map Type ImageKind FragmentOperationKind b)
-      -> (HList b
-        , [Fragment
+rasterizePrimitives
+  = \a b c d e -> _rhs
+    (foldr
+      ['Vector 1 ('Maybe ('SimpleFragment ('HList a)))]
+      ['Vector 1 ('Maybe ('SimpleFragment ('HList a)))]
+      ((++) ('Vector 1 ('Maybe ('SimpleFragment ('HList a)))))
+      []
+      (map
+        ('Primitive ('HList ('VecS 'Float 4 : a)) b)
+        ['Vector 1 ('Maybe ('SimpleFragment ('HList a)))]
+        (\f -> rasterizePrimitive
           a
-          (HList (imageType' (map Type ImageKind FragmentOperationKind b)))])
-        -> FrameBuffer a (map Type ImageKind FragmentOperationKind b)
-'GetImageKind :: Type -> ImageKind
-FrameBuffer
-  :: forall (a :: [Type])
-    . sameLayerCounts a
-      => HList a
-        -> FrameBuffer (ImageLC (head Type a)) (map Type ImageKind GetImageKind a)
-imageFrame
-  :: forall (a :: [Type])
-    . sameLayerCounts a
-      => HList a
-        -> FrameBuffer (ImageLC (head Type a)) (map Type ImageKind GetImageKind a)
-accumulate
-  :: forall (a :: Nat) (b :: [Type]) c
-    . HList b
-      -> (c -> HList (imageType' (map Type ImageKind FragmentOperationKind b)))
-        -> [Vector a (Maybe (SimpleFragment c))]
-          -> FrameBuffer a (map Type ImageKind FragmentOperationKind b)
-            -> FrameBuffer a (map Type ImageKind FragmentOperationKind b)
-PrjImage :: forall (a :: ImageKind) . FrameBuffer 1 ' [a] -> Image 1 a
-PrjImageColor
-  :: FrameBuffer 1 ' ['Depth, 'Color (Vec 4 Float)]
-    -> Image 1 ('Color (Vec 4 Float))
-'Output :: Type
-ScreenOut :: forall (a :: Nat) (b :: [ImageKind]) . FrameBuffer a b -> Output
-case'Output
-  :: forall (a :: Output -> Type)
-    -> (forall (b :: Nat) (c :: [ImageKind])
-        . forall (d :: FrameBuffer b c) -> a ('ScreenOut b c d))
-      -> forall (e :: Output) -> a e
-match'Output :: forall (a :: Type -> Type) -> a Output -> forall b -> a b -> a b
+          (map Type Type 'Interpolated a)
+          ('VecS 'Float 4 : a)
+          b
+          TT
+          TT
+          d
+          c
+          f)
+        e))
+
 renderFrame :: forall (a :: Nat) (b :: [ImageKind]) . FrameBuffer a b -> Output
-'Texture :: Type
-Texture2DSlot :: String -> Texture
-Texture2D :: Vec 2 Int -> Image 1 ('Color (Vec 4 Float)) -> Texture
-case'Texture
-  :: forall (a :: Texture -> Type)
-    -> (forall (b :: String) -> a ('Texture2DSlot b))
-      -> (forall (c :: Vec 2 Int) (d :: Image 1 ('Color (Vec 4 Float)))
-          -> a ('Texture2D c d))
-        -> forall (e :: Texture) -> a e
-match'Texture
-  :: forall (a :: Type -> Type) -> a Texture -> forall b -> a b -> a b
-'Filter :: Type
-PointFilter :: Filter
-LinearFilter :: Filter
-case'Filter
-  :: forall (a :: Filter -> Type)
-    -> a 'PointFilter -> a 'LinearFilter -> forall (b :: Filter) -> a b
-match'Filter :: forall (a :: Type -> Type) -> a Filter -> forall b -> a b -> a b
-'EdgeMode :: Type
-Repeat :: EdgeMode
-MirroredRepeat :: EdgeMode
-ClampToEdge :: EdgeMode
-case'EdgeMode
-  :: forall (a :: EdgeMode -> Type)
-    -> a 'Repeat
-      -> a 'MirroredRepeat -> a 'ClampToEdge -> forall (b :: EdgeMode) -> a b
-match'EdgeMode
-  :: forall (a :: Type -> Type) -> a EdgeMode -> forall b -> a b -> a b
-'Sampler :: Type
-Sampler :: Filter -> EdgeMode -> Texture -> Sampler
-case'Sampler
-  :: forall (a :: Sampler -> Type)
-    -> (forall (b :: Filter) (c :: EdgeMode) (d :: Texture) -> a ('Sampler b c d))
-      -> forall (e :: Sampler) -> a e
-match'Sampler
-  :: forall (a :: Type -> Type) -> a Sampler -> forall b -> a b -> a b
+renderFrame = _rhs ScreenOut
+
+sFragmentCoords :: forall a . SimpleFragment a -> VecS Float 3
+sFragmentCoords
+  = \_ a -> case'SimpleFragment (\_ -> 'VecS 'Float 3) (\b _ -> _rhs b) a
+
+sFragmentValue :: forall a . SimpleFragment a -> a
+sFragmentValue = \a b -> case'SimpleFragment (\_ -> a) (\_ c -> _rhs c) b
+
+sameLayerCounts :: [Type] -> Constraint
+sameLayerCounts = \a -> _rhs (allSame 'Nat (map Type 'Nat 'ImageLC a))
+
+swizzscalar :: forall a (b :: Nat) . Vec b a -> Swizz -> a
+swizzscalar
+  = \a b c d -> case'VecS
+    (\_ _ -> a)
+    (\e f -> case'Swizz
+      (\_ -> a)
+      (_rhs e)
+      (_rhs f)
+      (_rhs (undefined a))
+      (_rhs (undefined a))
+      d)
+    (\g h i -> case'Swizz
+      (\_ -> a)
+      (_rhs g)
+      (_rhs h)
+      (_rhs i)
+      (_rhs (undefined a))
+      d)
+    (\j k l m -> case'Swizz (\_ -> a) (_rhs j) (_rhs k) (_rhs l) (_rhs m) d)
+    b
+    c
+
+swizzvector
+  :: forall a (b :: Nat) (c :: Nat) . Vec b a -> Vec c Swizz -> VecS a c
+swizzvector
+  = \a b c d e -> case'Bool
+    (\_ -> 'VecS a c)
+    (_rhs (undefined ('VecS a c)))
+    (_rhs (mapVec 'Swizz a c (swizzscalar a b d) e))
+    (definedVec a b d)
+
 texture2D :: Sampler -> Vec 2 Float -> Vec 4 Float
-accumulationContext :: forall a . a -> a
+texture2D = \a b -> <<builtin>>
+
+zero :: forall a . Component a => a
+zero
+  = \a _ -> match'Int
+    (\b -> b)
+    (_rhs 0)
+    a
+    (match'Word
+      (\c -> c)
+      (_rhs (primIntToWord 0))
+      a
+      (match'Float
+        (\d -> d)
+        (_rhs 0.0)
+        a
+        (match'VecS
+          (\e -> e)
+          (\f g -> match'Float
+            (\h -> 'VecS h g)
+            (case'Nat
+              (\i -> 'VecS 'Float i)
+              (_rhs (undefined ('VecS 'Float 0)))
+              (\j -> case'Nat
+                (\k -> 'VecS 'Float (Succ k))
+                (_rhs (undefined ('VecS 'Float 1)))
+                (\l -> case'Nat
+                  (\m -> 'VecS 'Float (Succ (Succ m)))
+                  (_rhs (V2 0.0 0.0))
+                  (\n -> case'Nat
+                    (\o -> 'VecS 'Float (Succ (Succ (Succ o))))
+                    (_rhs (V3 0.0 0.0 0.0))
+                    (\p -> case'Nat
+                      (\q -> 'VecS 'Float (Succ (Succ (Succ (Succ q)))))
+                      (_rhs (V4 0.0 0.0 0.0 0.0))
+                      (\r -> _rhs (undefined ('VecS 'Float (Succ (Succ (Succ (Succ (Succ r))))))))
+                      p)
+                    n)
+                  l)
+                j)
+              g)
+            f
+            (match'Bool
+              (\s -> 'VecS s g)
+              (case'Nat
+                (\t -> 'VecS 'Bool t)
+                (_rhs (undefined ('VecS 'Bool 0)))
+                (\u -> case'Nat
+                  (\v -> 'VecS 'Bool (Succ v))
+                  (_rhs (undefined ('VecS 'Bool 1)))
+                  (\w -> case'Nat
+                    (\x -> 'VecS 'Bool (Succ (Succ x)))
+                    (_rhs (V2 False False))
+                    (\y -> case'Nat
+                      (\z -> 'VecS 'Bool (Succ (Succ (Succ z))))
+                      (_rhs (V3 False False False))
+                      (\a' -> case'Nat
+                        (\b' -> 'VecS 'Bool (Succ (Succ (Succ (Succ b')))))
+                        (_rhs (V4 False False False False))
+                        (\c' -> _rhs (undefined ('VecS 'Bool (Succ (Succ (Succ (Succ (Succ c'))))))))
+                        a')
+                      y)
+                    w)
+                  u)
+                g)
+              f
+              (_rhs (undefined ('VecS f g)))))
+          a
+          (match'Bool (\d' -> d') (_rhs False) a (_rhs (undefined a))))))
 ------------ tooltips
 testdata/Builtins.lc 10:1-10:3
     forall a . a -> a