main is not found
------------ desugared source code
id = _lhs id \(a :: _) -> _rhs a

data VecS (_ :: Type) :: Nat -> Type where
    V2 :: forall a . a -> a -> VecS a (fromInt 2)
    V3 :: forall b . b -> b -> b -> VecS b (fromInt 3)
    V4 :: forall c . c -> c -> c -> c -> VecS c (fromInt 4)

mapVec :: forall (a :: _) (b :: _) (c :: _) . (a -> b) -> VecS a c -> VecS b c
mapVec
  = _lhs
    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)))
      b

'Vec :: Nat -> Type -> Type
'Vec = _lhs 'Vec \(a :: _) (b :: _) -> _rhs ('VecS b a)

'VecScalar :: Nat -> Type -> Type
'VecScalar
  = _lhs
    'VecScalar
    \(a :: _) (b :: _) -> case'Nat
      (\(_ :: _) -> _)
      undefined
      (\(c :: _) -> case'Nat
        (\(_ :: _) -> _)
        (_rhs b)
        (\(d :: _) -> _rhs ('Vec (Succ (Succ d)) b))
        c)
      a

data Mat :: Nat -> Nat -> Type -> Type where
    M22F
      :: Vec (fromInt 2) Float
        -> Vec (fromInt 2) Float -> Mat (fromInt 2) (fromInt 2) Float
    M32F
      :: Vec (fromInt 3) Float
        -> Vec (fromInt 3) Float -> Mat (fromInt 3) (fromInt 2) Float
    M42F
      :: Vec (fromInt 4) Float
        -> Vec (fromInt 4) Float -> Mat (fromInt 4) (fromInt 2) Float
    M23F
      :: Vec (fromInt 2) Float
        -> Vec (fromInt 2) Float
          -> Vec (fromInt 2) Float -> Mat (fromInt 2) (fromInt 3) Float
    M33F
      :: Vec (fromInt 3) Float
        -> Vec (fromInt 3) Float
          -> Vec (fromInt 3) Float -> Mat (fromInt 3) (fromInt 3) Float
    M43F
      :: Vec (fromInt 4) Float
        -> Vec (fromInt 4) Float
          -> Vec (fromInt 4) Float -> Mat (fromInt 4) (fromInt 3) Float
    M24F
      :: Vec (fromInt 2) Float
        -> Vec (fromInt 2) Float
          -> Vec (fromInt 2) Float
            -> Vec (fromInt 2) Float -> Mat (fromInt 2) (fromInt 4) Float
    M34F
      :: Vec (fromInt 3) Float
        -> Vec (fromInt 3) Float
          -> Vec (fromInt 3) Float
            -> Vec (fromInt 3) Float -> Mat (fromInt 3) (fromInt 4) Float
    M44F
      :: Vec (fromInt 4) Float
        -> Vec (fromInt 4) Float
          -> Vec (fromInt 4) Float
            -> Vec (fromInt 4) Float -> Mat (fromInt 4) (fromInt 4) Float

'MatVecScalarElem :: Type -> Type
'MatVecScalarElem
  = _lhs
    'MatVecScalarElem
    \(a :: _) -> match'Float
      (\(_ :: _) -> _)
      (_rhs 'Float)
      a
      (match'Bool
        (\(_ :: _) -> _)
        (_rhs 'Bool)
        a
        (match'Int
          (\(_ :: _) -> _)
          (_rhs 'Int)
          a
          (match'VecS
            (\(_ :: _) -> _)
            (\(b :: _) (_ :: _) -> _rhs b)
            a
            (match'Mat
              (\(_ :: _) -> _)
              (\(_ :: _) (_ :: _) (c :: _) -> _rhs c)
              a
              undefined))))

'Signed :: Type -> Constraint
'Signed
  = _lhs
    'Signed
    \(a :: _) -> match'Int
      (\(_ :: _) -> _)
      (_rhs CUnit)
      a
      (match'Float
        (\(_ :: _) -> _)
        (_rhs CUnit)
        a
        (_rhs (CEmpty "no instance of 'Signed on ???")))

'Component :: Type -> Constraint
'Component
  = _lhs
    '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 ???"))
                        g)
                      f)
                    e)
                  d)
                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 ???"))
                          k)
                        j)
                      i)
                    h)
                  c)
                b
                (_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
  = _lhs
    zero
    \ @a @(_ :: _) -> match'Int
      (\(_ :: _) -> _)
      (_rhs let b = _lhs zero (_rhs (fromInt 0 :: Int)) in b)
      a
      (match'Word
        (\(_ :: _) -> _)
        (_rhs let c = _lhs zero (_rhs (fromInt 0 :: Word)) in c)
        a
        (match'Float
          (\(_ :: _) -> _)
          (_rhs let d = _lhs zero (_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 = _lhs zero (_rhs (V2 0.0 0.0)) in i)
                    (\(j :: _) -> case'Nat
                      (\(_ :: _) -> _)
                      (_rhs let k = _lhs zero (_rhs (V3 0.0 0.0 0.0)) in k)
                      (\(l :: _) -> case'Nat
                        (\(_ :: _) -> _)
                        (_rhs let m = _lhs zero (_rhs (V4 0.0 0.0 0.0 0.0)) in m)
                        (\(_ :: _) -> _rhs undefined)
                        l)
                      j)
                    h)
                  g)
                f)
              e
              (match'Bool
                (\(_ :: _) -> _)
                (case'Nat
                  (\(_ :: _) -> _)
                  (_rhs undefined)
                  (\(n :: _) -> case'Nat
                    (\(_ :: _) -> _)
                    (_rhs undefined)
                    (\(o :: _) -> case'Nat
                      (\(_ :: _) -> _)
                      (_rhs let p = _lhs zero (_rhs (V2 False False)) in p)
                      (\(q :: _) -> case'Nat
                        (\(_ :: _) -> _)
                        (_rhs let r = _lhs zero (_rhs (V3 False False False)) in r)
                        (\(s :: _) -> case'Nat
                          (\(_ :: _) -> _)
                          (_rhs let t = _lhs zero (_rhs (V4 False False False False)) in t)
                          (\(_ :: _) -> _rhs undefined)
                          s)
                        q)
                      o)
                    n)
                  f)
                e
                (_rhs undefined)))
            a
            (match'Bool
              (\(_ :: _) -> _)
              (_rhs let u = _lhs zero (_rhs False) in u)
              a
              (_rhs undefined)))))

one :: forall a . Component a => a
one
  = _lhs
    one
    \ @a @(_ :: _) -> match'Int
      (\(_ :: _) -> _)
      (_rhs let b = _lhs one (_rhs (fromInt 1 :: Int)) in b)
      a
      (match'Word
        (\(_ :: _) -> _)
        (_rhs let c = _lhs one (_rhs (fromInt 1 :: Word)) in c)
        a
        (match'Float
          (\(_ :: _) -> _)
          (_rhs let d = _lhs one (_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 = _lhs one (_rhs (V2 1.0 1.0)) in i)
                    (\(j :: _) -> case'Nat
                      (\(_ :: _) -> _)
                      (_rhs let k = _lhs one (_rhs (V3 1.0 1.0 1.0)) in k)
                      (\(l :: _) -> case'Nat
                        (\(_ :: _) -> _)
                        (_rhs let m = _lhs one (_rhs (V4 1.0 1.0 1.0 1.0)) in m)
                        (\(_ :: _) -> _rhs undefined)
                        l)
                      j)
                    h)
                  g)
                f)
              e
              (match'Bool
                (\(_ :: _) -> _)
                (case'Nat
                  (\(_ :: _) -> _)
                  (_rhs undefined)
                  (\(n :: _) -> case'Nat
                    (\(_ :: _) -> _)
                    (_rhs undefined)
                    (\(o :: _) -> case'Nat
                      (\(_ :: _) -> _)
                      (_rhs let p = _lhs one (_rhs (V2 True True)) in p)
                      (\(q :: _) -> case'Nat
                        (\(_ :: _) -> _)
                        (_rhs let r = _lhs one (_rhs (V3 True True True)) in r)
                        (\(s :: _) -> case'Nat
                          (\(_ :: _) -> _)
                          (_rhs let t = _lhs one (_rhs (V4 True True True True)) in t)
                          (\(_ :: _) -> _rhs undefined)
                          s)
                        q)
                      o)
                    n)
                  f)
                e
                (_rhs undefined)))
            a
            (match'Bool
              (\(_ :: _) -> _)
              (_rhs let u = _lhs one (_rhs True) in u)
              a
              (_rhs undefined)))))

'Integral :: Type -> Constraint
'Integral
  = _lhs
    'Integral
    \(a :: _) -> match'Int
      (\(_ :: _) -> _)
      (_rhs CUnit)
      a
      (match'Word
        (\(_ :: _) -> _)
        (_rhs CUnit)
        a
        (_rhs (CEmpty "no instance of 'Integral on ???")))

'Floating :: Type -> Constraint
'Floating
  = _lhs
    '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 ???"))
                    g)
                  f)
                e)
              d)
            c)
          b
          (_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 ???"))
                          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 ???"))
                            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 ???"))
                              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 ???"))))

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

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 :: _) . (Num a, b ~ VecScalar c a) => b -> b -> b

PrimMod
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> b -> b

PrimDivS
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> a -> b

PrimModS
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> a -> b

PrimNeg :: forall (a :: _) . Signed (MatVecScalarElem a) => a -> a

PrimBAnd
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> b -> b

PrimBOr
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> b -> b

PrimBXor
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> b -> b

PrimBAndS
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> a -> b

PrimBOrS
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> a -> b

PrimBXorS
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> a -> b

PrimBNot
  :: forall (a :: _) (b :: _) (c :: _) . (Integral a, b ~ VecScalar c a) => b -> b

PrimBShiftL
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Integral a, b ~ VecScalar c a, d ~ VecScalar c Word) => b -> d -> b

PrimBShiftR
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Integral a, b ~ VecScalar c a, d ~ VecScalar c Word) => b -> d -> b

PrimBShiftLS
  :: forall (a :: _) (b :: _) (c :: _)
    . (Integral a, b ~ VecScalar c a) => b -> Word -> b

PrimBShiftRS
  :: forall (a :: _) (b :: _) (c :: _)
    . (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 :: _) . (a ~ VecScalar b Bool) => a -> a

PrimAny :: forall (a :: _) . VecScalar a Bool -> Bool

PrimAll :: forall (a :: _) . VecScalar a Bool -> Bool

PrimACos :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimACosH :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimASin :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimASinH :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimATan :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimATanH :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimCos :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimCosH :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimDegrees :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimRadians :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimSin :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimSinH :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimTan :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimTanH :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimExp :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimLog :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimExp2 :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimLog2 :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimSqrt :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimInvSqrt :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimPow :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> a

PrimATan2 :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> a

PrimFloor :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimTrunc :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimRound :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimRoundEven :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimCeil :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimFract :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimMin
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> b -> b

PrimMax
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> b -> b

PrimMinS
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> a -> b

PrimMaxS
  :: forall (a :: _) (b :: _) (c :: _) . (Num a, b ~ VecScalar c a) => b -> a -> b

PrimIsNan
  :: forall (a :: _) (b :: _) (c :: _)
    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c

PrimIsInf
  :: forall (a :: _) (b :: _) (c :: _)
    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c

PrimAbs
  :: forall (a :: _) (b :: _) (c :: _) . (Signed a, b ~ VecScalar c a) => b -> b

PrimSign
  :: forall (a :: _) (b :: _) (c :: _) . (Signed a, b ~ VecScalar c a) => b -> b

PrimModF :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> (a, a)

PrimClamp
  :: forall (a :: _) (b :: _) (c :: _)
    . (Num a, b ~ VecScalar c a) => b -> b -> b -> b

PrimClampS
  :: forall (a :: _) (b :: _) (c :: _)
    . (Num a, b ~ VecScalar c a) => b -> a -> a -> b

PrimMix
  :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> a -> a

PrimMixS
  :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> Float -> a

PrimMixB
  :: forall (a :: _) (b :: _) (c :: _)
    . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> a -> c -> a

PrimStep :: forall (a :: _) (b :: _) . (a ~ Vec b Float) => a -> a -> a

PrimStepS
  :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => Float -> a -> a

PrimSmoothStep
  :: forall (a :: _) (b :: _) . (a ~ Vec b Float) => a -> a -> a -> a

PrimSmoothStepS
  :: forall (a :: _) (b :: _)
    . (a ~ VecScalar b Float) => Float -> Float -> a -> a

PrimFloatBitsToInt :: forall (a :: _) . VecScalar a Float -> VecScalar a Int

PrimFloatBitsToUInt :: forall (a :: _) . VecScalar a Float -> VecScalar a Word

PrimIntBitsToFloat :: forall (a :: _) . VecScalar a Int -> VecScalar a Float

PrimUIntBitsToFloat :: forall (a :: _) . VecScalar a Word -> VecScalar a Float

PrimLength :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> Float

PrimDistance
  :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> Float

PrimDot :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> Float

PrimCross :: forall (a :: _) . (a ~ VecScalar (fromInt 3) Float) => a -> a -> a

PrimNormalize :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimFaceForward
  :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> a -> a

PrimRefract
  :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> a -> a

PrimReflect :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a -> a

PrimTranspose :: forall (a :: _) (b :: _) (c :: _) . Mat a b c -> Mat b a c

PrimDeterminant :: forall (a :: _) (b :: _) . Mat a a b -> Float

PrimInverse :: forall (a :: _) (b :: _) . Mat a a b -> Mat a a b

PrimOuterProduct
  :: forall (a :: _) (b :: _) (c :: _) . Vec a b -> Vec c b -> Mat c a b

PrimMulMatVec
  :: forall (a :: _) (b :: _) (c :: _) . Mat a b c -> Vec b c -> Vec a c

PrimMulVecMat
  :: forall (a :: _) (b :: _) (c :: _) . Vec a b -> Mat a c b -> Vec c b

PrimMulMatMat
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . Mat a b c -> Mat b d c -> Mat a d c

PrimLessThan
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d

PrimLessThanEqual
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d

PrimGreaterThan
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d

PrimGreaterThanEqual
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d

PrimEqualV
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d

PrimNotEqualV
  :: forall (a :: _) (b :: _) (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 :: _) . (a ~ VecScalar b Float) => a -> a

PrimDFdy :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimFWidth :: forall (a :: _) (b :: _) . (a ~ VecScalar b Float) => a -> a

PrimNoise1 :: forall (a :: _) . VecScalar a Float -> Float

PrimNoise2 :: forall (a :: _) . VecScalar a Float -> Vec (fromInt 2) Float

PrimNoise3 :: forall (a :: _) . VecScalar a Float -> Vec (fromInt 3) Float

PrimNoise4 :: forall (a :: _) . VecScalar a Float -> Vec (fromInt 4) Float

head
  = _lhs
    head
    \(a :: _) -> case'List
      (\(_ :: _) -> _)
      (_rhs undefined)
      (\(b :: _) (_ :: _) -> _rhs b)
      a

(++)
  = primFix
    \(a :: _) -> _lhs
      (++)
      \(b :: _) (c :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs c)
        (\(d :: _) (e :: _) -> _rhs (d : a e c))
        b

foldr
  = primFix
    \(a :: _) -> _lhs
      foldr
      \(b :: _) (c :: _) (d :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs c)
        (\(e :: _) (f :: _) -> _rhs (b e (a b c f)))
        d

concat = _lhs concat (_rhs (foldr (++) []))

map
  = primFix
    \(a :: _) -> _lhs
      map
      \(b :: _) (c :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs [])
        (\(d :: _) (e :: _) -> _rhs (b d : a b e))
        c

concatMap :: forall (a :: _) (b :: _) . (a -> [b]) -> [a] -> [b]
concatMap = _lhs concatMap \(a :: _) (b :: _) -> _rhs (concat (map a b))

len
  = primFix
    \(a :: _) -> _lhs
      len
      \(b :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs (fromInt 0))
        (\(_ :: _) (c :: _) -> _rhs (fromInt 1 `primAddInt` a c))
        b

data Maybe (_ :: Type) :: Type where
    Nothing :: forall a . Maybe a
    Just :: forall b . b -> Maybe b

data Vector (_ :: Nat) (_ :: Type) :: Type where
    

data PrimitiveType :: Type where
    Triangle :: PrimitiveType
    Line :: PrimitiveType
    Point :: PrimitiveType
    TriangleAdjacency :: PrimitiveType
    LineAdjacency :: PrimitiveType

data Primitive (_ :: Type) :: PrimitiveType -> Type where
    PrimPoint :: forall a . a -> Primitive a Point
    PrimLine :: forall b . b -> b -> Primitive b Line
    PrimTriangle :: forall c . c -> c -> c -> Primitive c Triangle

mapPrimitive
  :: forall (a :: _) (b :: _) (c :: _)
    . (a -> b) -> Primitive a c -> Primitive b c

'PrimitiveStream
  = _lhs 'PrimitiveStream \(a :: _) (b :: _) -> _rhs ['Primitive b a]

mapPrimitives
  :: forall (a :: _) (b :: _) (c :: _)
    . (a -> b) -> PrimitiveStream c a -> PrimitiveStream c b
mapPrimitives = _lhs mapPrimitives \(a :: _) -> _rhs (map (mapPrimitive a))

'ListElem :: Type -> Type
'ListElem
  = _lhs
    'ListElem
    \(a :: _) -> match'List (\(_ :: _) -> _) (\(b :: _) -> _rhs b) a undefined

fetchArrays
  :: forall (a :: _) (b :: _) (c :: _)
    . (b ~ map ListElem c) => HList c -> PrimitiveStream a (HList b)

fetch
  :: forall (a :: _) (b :: _) . String -> HList b -> PrimitiveStream a (HList b)

Attribute :: forall (a :: _) . String -> a

fetchStream
  :: forall (a :: _) (b :: [Type])
    . String
      -> forall (c :: [String]) -> (len c ~ len b) => PrimitiveStream a (HList b)

data SimpleFragment (_ :: Type) :: Type where
    SimpleFragment :: forall a . Vec (fromInt 3) Float -> a -> SimpleFragment a

'Fragment
  = _lhs
    'Fragment
    \(a :: _) (b :: _) -> _rhs ('Vector a ('Maybe ('SimpleFragment b)))

sFragmentCoords
  = _lhs
    sFragmentCoords
    \(a :: _) -> case'SimpleFragment
      (\(_ :: _) -> _)
      (\(b :: _) (_ :: _) -> _rhs b)
      a

sFragmentValue
  = _lhs
    sFragmentValue
    \(a :: _) -> case'SimpleFragment
      (\(_ :: _) -> _)
      (\(_ :: _) (b :: _) -> _rhs b)
      a

'FragmentStream
  = _lhs 'FragmentStream \(a :: _) (b :: _) -> _rhs ['Fragment a b]

customizeDepth
  :: forall (a :: _) (b :: _) . (a -> Float) -> Fragment b a -> Fragment b a

customizeDepths
  :: forall (a :: _) (b :: _)
    . (a -> Float) -> FragmentStream b a -> FragmentStream b a
customizeDepths
  = _lhs customizeDepths \(a :: _) -> _rhs (map (customizeDepth a))

filterFragment
  :: forall (a :: _) (b :: _) . (a -> Bool) -> Fragment b a -> Fragment b a

filterFragments
  :: forall (a :: _) (b :: _)
    . (a -> Bool) -> FragmentStream b a -> FragmentStream b a
filterFragments
  = _lhs filterFragments \(a :: _) -> _rhs (map (filterFragment a))

mapFragment
  :: forall (a :: _) (b :: _) (c :: _) . (a -> b) -> Fragment c a -> Fragment c b

mapFragments
  :: forall (a :: _) (b :: _) (c :: _)
    . (a -> b) -> FragmentStream c a -> FragmentStream c b
mapFragments = _lhs mapFragments \(a :: _) -> _rhs (map (mapFragment a))

data ImageKind :: Type where
    Color :: Type -> ImageKind
    Depth :: ImageKind
    Stencil :: ImageKind

imageType :: ImageKind -> Type
imageType
  = _lhs
    imageType
    \(a :: _) -> case'ImageKind
      (\(_ :: _) -> _)
      (\(b :: _) -> _rhs b)
      (_rhs 'Float)
      (_rhs 'Int)
      a

data Image (_ :: Nat) (_ :: ImageKind) :: Type where
    

ColorImage
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (Num c, d ~ VecScalar b c) => d -> Image a (Color d)

DepthImage :: forall (a :: _) . Float -> Image a Depth

StencilImage :: forall (a :: _) . Int -> Image a Stencil

emptyDepthImage = _lhs emptyDepthImage (_rhs (DepthImage @(fromInt 1)))

emptyColorImage = _lhs emptyColorImage (_rhs (ColorImage @(fromInt 1)))

data Swizz :: Type where
    Sx :: Swizz
    Sy :: Swizz
    Sz :: Swizz
    Sw :: Swizz

swizzscalar :: forall (a :: _) (b :: _) . Vec b a -> Swizz -> a
swizzscalar
  = _lhs
    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)
        (_rhs k)
        b)
      a

definedVec :: forall (a :: _) (b :: _) . Vec b a -> Bool
definedVec
  = _lhs
    definedVec
    \(a :: _) -> case'VecS
      (\(_ :: _) (_ :: _) -> _)
      (\(_ :: _) (_ :: _) -> _rhs True)
      (\(_ :: _) (_ :: _) (_ :: _) -> _rhs True)
      (\(_ :: _) (_ :: _) (_ :: _) (_ :: _) -> _rhs True)
      a

swizzvector
  :: forall (a :: _) (b :: _) (c :: _) . Vec b a -> Vec c Swizz -> Vec c a
swizzvector
  = _lhs
    swizzvector
    \(a :: _) (b :: _) -> case'Bool
      (\(_ :: _) -> _)
      (_rhs undefined)
      (_rhs (mapVec (swizzscalar a) b))
      (definedVec a)

data BlendingFactor :: Type where
    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

data BlendEquation :: Type where
    FuncAdd :: BlendEquation
    FuncSubtract :: BlendEquation
    FuncReverseSubtract :: BlendEquation
    Min :: BlendEquation
    Max :: BlendEquation

data LogicOperation :: Type where
    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

data StencilOperation :: Type where
    OpZero :: StencilOperation
    OpKeep :: StencilOperation
    OpReplace :: StencilOperation
    OpIncr :: StencilOperation
    OpIncrWrap :: StencilOperation
    OpDecr :: StencilOperation
    OpDecrWrap :: StencilOperation
    OpInvert :: StencilOperation

data ComparisonFunction :: Type where
    Never :: ComparisonFunction
    Less :: ComparisonFunction
    Equal :: ComparisonFunction
    Lequal :: ComparisonFunction
    Greater :: ComparisonFunction
    Notequal :: ComparisonFunction
    Gequal :: ComparisonFunction
    Always :: ComparisonFunction

data ProvokingVertex :: Type where
    LastVertex :: ProvokingVertex
    FirstVertex :: ProvokingVertex

data CullMode :: Type where
    CullFront :: CullMode
    CullBack :: CullMode
    CullNone :: CullMode

data PointSize (_ :: Type) :: Type where
    PointSize :: forall a . Float -> PointSize a
    ProgramPointSize :: forall b . (b -> Float) -> PointSize b

data PolygonMode (_ :: Type) :: Type where
    PolygonFill :: forall a . PolygonMode a
    PolygonPoint :: forall b . PointSize b -> PolygonMode b
    PolygonLine :: forall c . Float -> PolygonMode c

data PolygonOffset :: Type where
    NoOffset :: PolygonOffset
    Offset :: Float -> Float -> PolygonOffset

data PointSpriteCoordOrigin :: Type where
    LowerLeft :: PointSpriteCoordOrigin
    UpperLeft :: PointSpriteCoordOrigin

primTexture :: () -> Vec (fromInt 2) Float -> Vec (fromInt 4) Float

Uniform :: forall (a :: _) . String -> a

data RasterContext (_ :: Type) :: PrimitiveType -> Type where
    TriangleCtx
      :: forall a
        . CullMode
          -> PolygonMode a -> PolygonOffset -> ProvokingVertex -> RasterContext a Triangle
    PointCtx
      :: forall b
        . PointSize b -> Float -> PointSpriteCoordOrigin -> RasterContext b Point
    LineCtx :: forall c . Float -> ProvokingVertex -> RasterContext c Line

data Blending :: Type -> Type where
    NoBlending :: forall (a :: _) . Blending a
    BlendLogicOp :: forall (b :: _) . Integral b => LogicOperation -> Blending b
    Blend
      :: (BlendEquation, BlendEquation)
        -> ((BlendingFactor, BlendingFactor), (BlendingFactor, BlendingFactor))
          -> Vec (fromInt 4) Float -> Blending Float

data StencilTests :: Type where
    

data StencilOps :: Type where
    

data FragmentOperation :: ImageKind -> Type where
    ColorOp
      :: forall (a :: _) (b :: _)
        . Num a
          => Blending a -> VecScalar b Bool -> FragmentOperation (Color (VecScalar b a))
    DepthOp :: ComparisonFunction -> Bool -> FragmentOperation Depth
    StencilOp
      :: StencilTests -> StencilOps -> StencilOps -> FragmentOperation Stencil

data Interpolated (_ :: Type) :: Type where
    Smooth :: forall a . Floating a => Interpolated a
    NoPerspective :: forall b . Floating b => Interpolated b
    Flat :: forall c . Interpolated c

rasterizePrimitive
  :: forall (a :: _) (b :: _) (c :: _) (d :: _)
    . (map Interpolated a ~ b, c ~ Vec (fromInt 4) Float : a)
      => HList b
        -> RasterContext (HList c) d
          -> Primitive (HList c) d -> FragmentStream (fromInt 1) (HList a)

rasterizePrimitives
  = _lhs
    rasterizePrimitives
    \(a :: _) (b :: _) (c :: _) -> _rhs (concat (map (rasterizePrimitive b a) c))

'ImageLC :: Type -> Nat
'ImageLC
  = _lhs
    'ImageLC
    \(a :: _) -> match'Image
      (\(_ :: _) -> _)
      (\(b :: _) (_ :: _) -> _rhs b)
      a
      undefined

allSame :: forall (a :: _) . [a] -> Constraint
allSame
  = primFix
    \(a :: _) -> _lhs
      allSame
      \(b :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs 'CUnit)
        (\(c :: _) (d :: _) -> case'List
          (\(_ :: _) -> _)
          (_rhs 'CUnit)
          (\(e :: _) (f :: _) -> _rhs ('T2 (c `'EqCTt` e) (a (e : f))))
          d)
        b

sameLayerCounts
  = _lhs sameLayerCounts \(a :: _) -> _rhs (allSame (map 'ImageLC a))

data FrameBuffer (_ :: Nat) (_ :: [ImageKind]) :: Type where
    

imageType' :: [ImageKind] -> [Type]
imageType'
  = _lhs
    imageType'
    \(a :: _) -> case'List
      (\(_ :: _) -> _)
      (_rhs (map imageType a))
      (\(b :: _) (c :: _) -> case'ImageKind
        (\(_ :: _) -> _)
        (\(_ :: _) -> _rhs (map imageType a))
        (_rhs (map imageType c))
        (_rhs (map imageType a))
        b)
      a

'FragmentOperationKind :: Type -> ImageKind
'FragmentOperationKind
  = _lhs
    'FragmentOperationKind
    \(a :: _) -> match'FragmentOperation
      (\(_ :: _) -> _)
      (\(b :: _) -> _rhs b)
      a
      undefined

Accumulate
  :: forall (a :: _) (b :: Nat) (c :: [Type])
    . (a ~ map FragmentOperationKind c)
      => HList c
        -> FragmentStream b (HList (imageType' a)) -> FrameBuffer b a -> FrameBuffer b a

accumulateWith = _lhs accumulateWith \(a :: _) (b :: _) -> _rhs (a, b)

overlay
  = _lhs
    overlay
    \(a :: _) (b :: _) -> hlistConsCase
      _
      (\(c :: _) (d :: _) -> hlistConsCase
        _
        (\(e :: _) (f :: _) -> hlistNilCase _ (_rhs (Accumulate c e a)) f)
        d)
      b

infixl 0 overlay

'GetImageKind :: Type -> ImageKind
'GetImageKind
  = _lhs
    'GetImageKind
    \(a :: _) -> match'Image
      (\(_ :: _) -> _)
      (\(_ :: _) (b :: _) -> _rhs b)
      a
      undefined

FrameBuffer
  :: forall (a :: [Type])
    . sameLayerCounts a
      => HList a -> FrameBuffer (ImageLC (head a)) (map GetImageKind a)

imageFrame = _lhs imageFrame (_rhs FrameBuffer)

accumulate
  = _lhs
    accumulate
    \(a :: _) (b :: _) (c :: _) (d :: _) -> _rhs (Accumulate a (mapFragments b c) d)

PrjImage
  :: forall (a :: _) . FrameBuffer (fromInt 1) ' [a] -> Image (fromInt 1) a

PrjImageColor
  :: FrameBuffer (fromInt 1) ' ['Depth, 'Color (Vec (fromInt 4) Float)]
    -> Image (fromInt 1) (Color (Vec (fromInt 4) Float))

data Output :: Type where
    ScreenOut :: forall (a :: _) (b :: _) . FrameBuffer a b -> Output

renderFrame = _lhs renderFrame (_rhs ScreenOut)

data Texture :: Type where
    Texture2DSlot :: String -> Texture
    Texture2D
      :: Vec (fromInt 2) Int
        -> Image (fromInt 1) (Color (Vec (fromInt 4) Float)) -> Texture

data Filter :: Type where
    PointFilter :: Filter
    LinearFilter :: Filter

data EdgeMode :: Type where
    Repeat :: EdgeMode
    MirroredRepeat :: EdgeMode
    ClampToEdge :: EdgeMode

data Sampler :: Type where
    Sampler :: Filter -> EdgeMode -> Texture -> Sampler

texture2D :: Sampler -> Vec (fromInt 2) Float -> Vec (fromInt 4) Float

accumulationContext = _lhs accumulationContext \(a :: _) -> _rhs a
------------ 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 ['Fragment a 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
'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
    _
    \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 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 a)) (map 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
M22F = <<0th constructor of 'Mat>>

M23F :: Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Mat 2 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
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
PrimAdd = \a b c d -> <<delta function with arity 4>>

PrimAddS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
PrimAddS = \a b c d e f -> <<delta function with arity 6>>

PrimAll :: forall (a :: Nat) . VecScalar a Bool -> Bool
PrimAll = \a b -> <<builtin>>

PrimAnd :: Bool -> Bool -> Bool
PrimAnd = \a b -> <<delta function with arity 2>>

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
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
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
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
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
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
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
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
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 -> <<delta function with arity 7>>

PrimDivS :: forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
PrimDivS = \a b c d e f g -> <<delta function with arity 7>>

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 -> <<delta function with arity 5>>

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 -> <<delta function with arity 9>>

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 -> <<delta function with arity 9>>

PrimGreaterThanEqual
  :: forall a (b :: Nat) c d
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
PrimGreaterThanEqual = \a b c d e f g h i -> <<delta function with arity 9>>

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
PrimLessThan = \a b c d e f g h i -> <<delta function with arity 9>>

PrimLessThanEqual
  :: forall a (b :: Nat) c d
    . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
PrimLessThanEqual = \a b c d e f g h i -> <<delta function with arity 9>>

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 -> <<delta function with arity 7>>

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 -> <<delta function with arity 7>>

PrimMul :: forall a . Num (MatVecScalarElem a) => a -> a -> a
PrimMul = \a b c d -> <<delta function with arity 4>>

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 -> <<delta function with arity 6>>

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 -> <<delta function with arity 3>>

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
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 -> <<delta function with arity 4>>

PrimNotEqual :: forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
PrimNotEqual = \a b c d e -> <<delta function with arity 5>>

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 -> <<delta function with arity 9>>

PrimOr :: Bool -> Bool -> Bool
PrimOr = \a b -> <<delta function with arity 2>>

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
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 -> <<delta function with arity 4>>

PrimSubS :: forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
PrimSubS = \a b c d e f -> <<delta function with arity 6>>

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
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 -> <<delta function with arity 2>>

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
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
Stencil = <<2nd constructor of 'ImageKind>>

StencilImage :: forall (a :: Nat) . Int -> Image a 'Stencil
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
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
ZeroBF = <<0th constructor of 'BlendingFactor>>

accumulate
  :: forall (a :: Nat) (b :: [Type]) c
    . HList b
      -> (c -> HList (imageType' (map FragmentOperationKind b)))
        -> [Vector a (Maybe (SimpleFragment c))]
          -> FrameBuffer a (map FragmentOperationKind b)
            -> FrameBuffer a (map FragmentOperationKind b)
accumulate
  = \a b c d e f g -> _rhs
    (Accumulate
      (map 'FragmentOperationKind b)
      a
      b
      TT
      d
      (map
        (\h -> mapFragment c ('HList (imageType' (map '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 b -> _rhs b

allSame :: forall a . [a] -> Constraint
allSame
  = primFix
    _
    \a b c -> case'List
      (\_ -> 'Constraint)
      (_rhs CUnit)
      (\d e -> case'List
        (\_ -> 'Constraint)
        (_rhs CUnit)
        (\f g -> _rhs ('T2 (d ~ (f :: b)) (a b (f : g))))
        e)
      c

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
      -> a 'OneBF
        -> a 'SrcColor
          -> a 'OneMinusSrcColor
            -> a 'DstColor
              -> a 'OneMinusDstColor
                -> a 'SrcAlpha
                  -> a 'OneMinusSrcAlpha
                    -> a 'DstAlpha
                      -> a 'OneMinusDstAlpha
                        -> a 'ConstantColor
                          -> a 'OneMinusConstantColor
                            -> a 'ConstantAlpha
                              -> a 'OneMinusConstantAlpha
                                -> a 'SrcAlphaSaturate -> forall (b :: BlendingFactor) -> a b
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
      -> a 'And
        -> a 'AndReverse
          -> a 'Copy
            -> a 'AndInverted
              -> a 'Noop
                -> a 'Xor
                  -> a 'Or
                    -> a 'Nor
                      -> a 'Equiv
                        -> a 'Invert
                          -> a 'OrReverse
                            -> a 'CopyInverted
                              -> a 'OrInverted -> a 'Nand -> a 'Set -> forall (b :: LogicOperation) -> a b
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
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)
      -> b 'PolygonFill
        -> (forall (c :: PointSize a) -> b ('PolygonPoint c))
          -> (forall (d :: Float) -> b ('PolygonLine d))
            -> forall (e :: PolygonMode a) -> b e
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
case'PolygonOffset = \a b c d -> <<case function of a type with 0 parameters>>

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
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)
      -> (forall (d :: CullMode)
            (e :: PolygonMode a) (f :: PolygonOffset) (g :: ProvokingVertex)
          -> b 'Triangle ('TriangleCtx d e f g))
        -> (forall (h :: PointSize a) (i :: Float) (j :: PointSpriteCoordOrigin)
            -> 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
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
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 (++) [])

concatMap :: forall a b . (a -> [b]) -> [a] -> [b]
concatMap = \a b c d -> _rhs (foldr (++) [] (map 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)
    . (a -> Float)
      -> [Vector b (Maybe (SimpleFragment a))]
        -> [Vector b (Maybe (SimpleFragment a))]
customizeDepths = \a b c -> _rhs (map \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 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 c ~ (len 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 \d -> filterFragment a b c d)

foldr :: forall a b . (b -> a -> a) -> a -> [b] -> a
foldr
  = \a b -> primFix
    _
    \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 b -> _rhs b

imageFrame
  :: forall (a :: [Type])
    . sameLayerCounts a
      => HList a -> FrameBuffer (ImageLC (head a)) (map 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 imageType a))
    (\b c -> case'ImageKind
      (\_ -> [Type])
      (\_ -> _rhs (map imageType a))
      (_rhs (map imageType c))
      (_rhs (map imageType a))
      b)
    a

len :: forall a . [a] -> Int
len
  = \a -> primFix
    _
    \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
    _
    \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 \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 \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
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 FragmentOperationKind b)
      -> (HList b, [Fragment a (HList (imageType' (map FragmentOperationKind b)))])
        -> FrameBuffer a (map FragmentOperationKind b)
overlay
  = \a b c d -> hlistConsCase
    ('HList b)
    [['Fragment a ('HList (imageType' (map 'FragmentOperationKind b)))]]
    ('FrameBuffer a (map 'FragmentOperationKind b))
    (\e f -> hlistConsCase
      ['Fragment a ('HList (imageType' (map 'FragmentOperationKind b)))]
      []
      ('FrameBuffer a (map 'FragmentOperationKind b))
      (\g h -> hlistNilCase
        ('FrameBuffer a (map 'FragmentOperationKind b))
        (_rhs (Accumulate (map '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 Interpolated a ~ (b :: [Type]), c ~ (Vec 4 Float : a :: [Type]))
      => 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 Interpolated a)
        -> [Primitive (HList (Vec 4 Float : a)) b]
          -> [Vector 1 (Maybe (SimpleFragment (HList a)))]
rasterizePrimitives
  = \a b c d e -> _rhs
    (foldr
      (++)
      []
      (map
        (\f -> rasterizePrimitive
          a
          (map 'Interpolated a)
          ('Vec 4 'Float : a)
          b
          TT
          TT
          d
          c
          f)
        e))

renderFrame :: forall (a :: Nat) (b :: [ImageKind]) . FrameBuffer a b -> Output
renderFrame = _rhs ScreenOut

sFragmentCoords :: forall a . SimpleFragment a -> VecS Float 3
sFragmentCoords
  = \a b -> case'SimpleFragment (\_ -> 'VecS 'Float 3) (\c _ -> _rhs c) b

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 '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
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
10:1-10:3
    forall a . a -> a
10:8-10:9
    _b
14:6-14:10
    Type -> Nat -> Type | Type -> Nat -> Type | Type | Type
      -> Nat -> Type | Type | Type
14:6-17:37
    Type | Type | Type | Type
14:17-14:21
    Type | Type | Type | Type | Type
14:26-14:29
    Type
14:26-14:37
    Type
14:33-14:37
    Type | Type
15:3-15:5
    forall a . a -> a -> VecS a 2 | VecS _d 2
15:3-15:27
    Type | Type | Type
15:9-15:10
    Type
15:9-15:27
    Type
15:14-15:15
    Type
15:14-15:27
    Type
15:19-15:23
    Type -> Nat -> Type
15:19-15:25
    Nat -> Type
15:19-15:27
    Type | Type
15:24-15:25
    Type
15:26-15:27
    _b | _b
16:3-16:5
    forall a . a -> a -> a -> VecS a 3 | VecS _f 3
16:3-16:32
    Type | Type | Type | Type
16:9-16:10
    Type
16:9-16:32
    Type
16:14-16:15
    Type
16:14-16:32
    Type
16:19-16:20
    Type
16:19-16:32
    Type
16:24-16:28
    Type -> Nat -> Type
16:24-16:30
    Nat -> Type
16:24-16:32
    Type | Type
16:29-16:30
    Type
16:31-16:32
    _b | _b
17:3-17:5
    forall a . a -> a -> a -> a -> VecS a 4 | VecS _h 4
17:3-17:37
    Type | Type | Type | Type | Type
17:9-17:10
    Type
17:9-17:37
    Type
17:14-17:15
    Type
17:14-17:37
    Type
17:19-17:20
    Type
17:19-17:37
    Type
17:24-17:25
    Type
17:24-17:37
    Type
17:29-17:33
    Type -> Nat -> Type
17:29-17:35
    Nat -> Type
17:29-17:37
    Type | Type
17:34-17:35
    Type
17:36-17:37
    _b | _b
19:11-19:43
    Type | Type | Type
19:12-19:13
    _f
19:17-19:18
    _e | Type
19:23-19:27
    Type -> Nat -> Type
19:23-19:29
    Nat -> Type
19:23-19:31
    Type
19:23-19:43
    Type
19:28-19:29
    Type
19:30-19:31
    _c
19:35-19:39
    Type -> Nat -> Type
19:35-19:41
    Nat -> Type
19:35-19:43
    Type | Type
19:40-19:41
    Type
19:42-19:43
    Nat
20:1-20:7
    forall a b (c :: Nat) . (a -> b) -> VecS a c -> VecS b c
20:21-20:23
    forall a . a -> a -> VecS a 2
20:21-20:29
    _f -> VecS _f 2
20:21-20:35
    VecS _f 2
20:21-21:43
    (forall (a :: _e) (b :: _e) (c :: _e) -> _e -> VecS _d 4)
      -> forall (d :: Nat) . VecS _e d -> VecS _d d
20:21-22:51
    forall (a :: Nat) . VecS _e a -> VecS _d a
20:25-20:26
    _i -> _h
20:25-20:28
    _f
20:27-20:28
    _c
20:31-20:32
    _g -> _f
20:31-20:34
    _f
20:33-20:34
    _g
21:23-21:25
    forall a . a -> a -> a -> VecS a 3
21:23-21:31
    _g -> _g -> VecS _g 3
21:23-21:37
    _g -> VecS _g 3
21:23-21:43
    VecS _g 3
21:27-21:28
    _i -> _h
21:27-21:30
    _g
21:29-21:30
    _h
21:33-21:34
    _h -> _g
21:33-21:36
    _g
21:35-21:36
    _h
21:39-21:40
    _h -> _g
21:39-21:42
    _g
21:41-21:42
    _h
22:25-22:27
    forall a . a -> a -> a -> a -> VecS a 4
22:25-22:33
    _h -> _h -> _h -> VecS _h 4
22:25-22:39
    _h -> _h -> VecS _h 4
22:25-22:45
    _h -> VecS _h 4
22:25-22:51
    VecS _h 4
22:29-22:30
    _j -> _i
22:29-22:32
    _h
22:31-22:32
    _i
22:35-22:36
    _i -> _h
22:35-22:38
    _h
22:37-22:38
    _i
22:41-22:42
    _i -> _h
22:41-22:44
    _h
22:43-22:44
    _i
22:47-22:48
    _i -> _h
22:47-22:50
    _h
22:49-22:50
    _i
24:23-24:26
    Type
24:37-24:40
    Nat -> Type -> Type
24:47-24:51
    Type -> Nat -> Type
24:47-24:53
    Nat -> Type
24:47-24:55
    Type
24:52-24:53
    Type
24:54-24:55
    Nat
27:29-27:32
    Type
28:5-28:14
    Nat -> Type -> Type
28:21-28:22
    Type
28:21-29:60
    Nat -> Type
29:37-29:40
    Nat -> Type -> Type
29:37-29:58
    Type -> Type
29:37-29:60
    Type
29:42-29:47
    Nat -> Nat
29:42-29:57
    Nat
29:49-29:54
    Nat -> Nat
29:49-29:56
    Nat
29:55-29:56
    Nat
29:59-29:60
    Type
32:6-32:9
    Nat -> Nat -> Type -> Type | Nat
      -> Nat -> Type -> Type | Type | Type | Type | Nat
      -> Nat -> Type -> Type | Type | Type | Type | Type
32:6-41:84
    Type | Type | Type | Type | Type | Type | Type | Type | Type
32:13-32:16
    Type
32:20-32:23
    Type
32:20-32:39
    Type
32:27-32:31
    Type
32:27-32:39
    Type
32:35-32:39
    Type | Type
33:3-33:7
    Vec 2 Float -> Vec 2 Float -> Mat 2 2 Float | Mat 2 2 Float
33:3-33:54
    Type | Type | Type
33:11-33:14
    Nat -> Type -> Type
33:11-33:16
    Type -> Type
33:11-33:22
    Type
33:15-33:16
    _b
33:17-33:22
    Type
33:26-33:29
    Nat -> Type -> Type
33:26-33:31
    Type -> Type
33:26-33:37
    Type
33:26-33:54
    Type
33:30-33:31
    _b
33:32-33:37
    Type
33:41-33:44
    Nat -> Nat -> Type -> Type
33:41-33:46
    Nat -> Type -> Type
33:41-33:48
    Type -> Type
33:41-33:54
    Type | Type
33:45-33:46
    _b | _b
33:45-33:48
    forall a -> Mat 2 2 a -> Type
33:45-33:54
    Mat 2 2 Float -> Type
33:47-33:48
    _b | _b
33:49-33:54
    Type | Type
34:3-34:7
    Vec 3 Float -> Vec 3 Float -> Mat 3 2 Float | Mat 3 2 Float
34:3-34:54
    Type | Type | Type
34:11-34:14
    Nat -> Type -> Type
34:11-34:16
    Type -> Type
34:11-34:22
    Type
34:15-34:16
    _b
34:17-34:22
    Type
34:26-34:29
    Nat -> Type -> Type
34:26-34:31
    Type -> Type
34:26-34:37
    Type
34:26-34:54
    Type
34:30-34:31
    _b
34:32-34:37
    Type
34:41-34:44
    Nat -> Nat -> Type -> Type
34:41-34:46
    Nat -> Type -> Type
34:41-34:48
    Type -> Type
34:41-34:54
    Type | Type
34:45-34:46
    _b | _b
34:45-34:48
    forall a -> Mat 3 2 a -> Type
34:45-34:54
    Mat 3 2 Float -> Type
34:47-34:48
    _b | _b
34:49-34:54
    Type | Type
35:3-35:7
    Vec 4 Float -> Vec 4 Float -> Mat 4 2 Float | Mat 4 2 Float
35:3-35:54
    Type | Type | Type
35:11-35:14
    Nat -> Type -> Type
35:11-35:16
    Type -> Type
35:11-35:22
    Type
35:15-35:16
    _b
35:17-35:22
    Type
35:26-35:29
    Nat -> Type -> Type
35:26-35:31
    Type -> Type
35:26-35:37
    Type
35:26-35:54
    Type
35:30-35:31
    _b
35:32-35:37
    Type
35:41-35:44
    Nat -> Nat -> Type -> Type
35:41-35:46
    Nat -> Type -> Type
35:41-35:48
    Type -> Type
35:41-35:54
    Type | Type
35:45-35:46
    _b | _b
35:45-35:48
    forall a -> Mat 4 2 a -> Type
35:45-35:54
    Mat 4 2 Float -> Type
35:47-35:48
    _b | _b
35:49-35:54
    Type | Type
36:3-36:7
    Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Mat 2 3 Float | Mat 2 3 Float
36:3-36:69
    Type | Type | Type | Type
36:11-36:14
    Nat -> Type -> Type
36:11-36:16
    Type -> Type
36:11-36:22
    Type
36:15-36:16
    _b
36:17-36:22
    Type
36:26-36:29
    Nat -> Type -> Type
36:26-36:31
    Type -> Type
36:26-36:37
    Type
36:26-36:69
    Type
36:30-36:31
    _b
36:32-36:37
    Type
36:41-36:44
    Nat -> Type -> Type
36:41-36:46
    Type -> Type
36:41-36:52
    Type
36:41-36:69
    Type
36:45-36:46
    _b
36:47-36:52
    Type
36:56-36:59
    Nat -> Nat -> Type -> Type
36:56-36:61
    Nat -> Type -> Type
36:56-36:63
    Type -> Type
36:56-36:69
    Type | Type
36:60-36:61
    _b | _b
36:60-36:63
    forall a -> Mat 2 3 a -> Type
36:60-36:69
    Mat 2 3 Float -> Type
36:62-36:63
    _b | _b
36:64-36:69
    Type | Type
37:3-37:7
    Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Mat 3 3 Float | Mat 3 3 Float
37:3-37:69
    Type | Type | Type | Type
37:11-37:14
    Nat -> Type -> Type
37:11-37:16
    Type -> Type
37:11-37:22
    Type
37:15-37:16
    _b
37:17-37:22
    Type
37:26-37:29
    Nat -> Type -> Type
37:26-37:31
    Type -> Type
37:26-37:37
    Type
37:26-37:69
    Type
37:30-37:31
    _b
37:32-37:37
    Type
37:41-37:44
    Nat -> Type -> Type
37:41-37:46
    Type -> Type
37:41-37:52
    Type
37:41-37:69
    Type
37:45-37:46
    _b
37:47-37:52
    Type
37:56-37:59
    Nat -> Nat -> Type -> Type
37:56-37:61
    Nat -> Type -> Type
37:56-37:63
    Type -> Type
37:56-37:69
    Type | Type
37:60-37:61
    _b | _b
37:60-37:63
    forall a -> Mat 3 3 a -> Type
37:60-37:69
    Mat 3 3 Float -> Type
37:62-37:63
    _b | _b
37:64-37:69
    Type | Type
38:3-38:7
    Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Mat 4 3 Float | Mat 4 3 Float
38:3-38:69
    Type | Type | Type | Type
38:11-38:14
    Nat -> Type -> Type
38:11-38:16
    Type -> Type
38:11-38:22
    Type
38:15-38:16
    _b
38:17-38:22
    Type
38:26-38:29
    Nat -> Type -> Type
38:26-38:31
    Type -> Type
38:26-38:37
    Type
38:26-38:69
    Type
38:30-38:31
    _b
38:32-38:37
    Type
38:41-38:44
    Nat -> Type -> Type
38:41-38:46
    Type -> Type
38:41-38:52
    Type
38:41-38:69
    Type
38:45-38:46
    _b
38:47-38:52
    Type
38:56-38:59
    Nat -> Nat -> Type -> Type
38:56-38:61
    Nat -> Type -> Type
38:56-38:63
    Type -> Type
38:56-38:69
    Type | Type
38:60-38:61
    _b | _b
38:60-38:63
    forall a -> Mat 4 3 a -> Type
38:60-38:69
    Mat 4 3 Float -> Type
38:62-38:63
    _b | _b
38:64-38:69
    Type | Type
39:3-39:7
    Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Vec 2 Float -> Mat 2 4 Float | Mat
      2
      4
      Float
39:3-39:84
    Type | Type | Type | Type | Type
39:11-39:14
    Nat -> Type -> Type
39:11-39:16
    Type -> Type
39:11-39:22
    Type
39:15-39:16
    _b
39:17-39:22
    Type
39:26-39:29
    Nat -> Type -> Type
39:26-39:31
    Type -> Type
39:26-39:37
    Type
39:26-39:84
    Type
39:30-39:31
    _b
39:32-39:37
    Type
39:41-39:44
    Nat -> Type -> Type
39:41-39:46
    Type -> Type
39:41-39:52
    Type
39:41-39:84
    Type
39:45-39:46
    _b
39:47-39:52
    Type
39:56-39:59
    Nat -> Type -> Type
39:56-39:61
    Type -> Type
39:56-39:67
    Type
39:56-39:84
    Type
39:60-39:61
    _b
39:62-39:67
    Type
39:71-39:74
    Nat -> Nat -> Type -> Type
39:71-39:76
    Nat -> Type -> Type
39:71-39:78
    Type -> Type
39:71-39:84
    Type | Type
39:75-39:76
    _b | _b
39:75-39:78
    forall a -> Mat 2 4 a -> Type
39:75-39:84
    Mat 2 4 Float -> Type
39:77-39:78
    _b | _b
39:79-39:84
    Type | Type
40:3-40:7
    Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Vec 3 Float -> Mat 3 4 Float | Mat
      3
      4
      Float
40:3-40:84
    Type | Type | Type | Type | Type
40:11-40:14
    Nat -> Type -> Type
40:11-40:16
    Type -> Type
40:11-40:22
    Type
40:15-40:16
    _b
40:17-40:22
    Type
40:26-40:29
    Nat -> Type -> Type
40:26-40:31
    Type -> Type
40:26-40:37
    Type
40:26-40:84
    Type
40:30-40:31
    _b
40:32-40:37
    Type
40:41-40:44
    Nat -> Type -> Type
40:41-40:46
    Type -> Type
40:41-40:52
    Type
40:41-40:84
    Type
40:45-40:46
    _b
40:47-40:52
    Type
40:56-40:59
    Nat -> Type -> Type
40:56-40:61
    Type -> Type
40:56-40:67
    Type
40:56-40:84
    Type
40:60-40:61
    _b
40:62-40:67
    Type
40:71-40:74
    Nat -> Nat -> Type -> Type
40:71-40:76
    Nat -> Type -> Type
40:71-40:78
    Type -> Type
40:71-40:84
    Type | Type
40:75-40:76
    _b | _b
40:75-40:78
    forall a -> Mat 3 4 a -> Type
40:75-40:84
    Mat 3 4 Float -> Type
40:77-40:78
    _b | _b
40:79-40:84
    Type | Type
41:3-41:7
    Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Vec 4 Float -> Mat 4 4 Float | Mat
      4
      4
      Float
41:3-41:84
    Type | Type | Type | Type | Type
41:11-41:14
    Nat -> Type -> Type
41:11-41:16
    Type -> Type
41:11-41:22
    Type
41:15-41:16
    _b
41:17-41:22
    Type
41:26-41:29
    Nat -> Type -> Type
41:26-41:31
    Type -> Type
41:26-41:37
    Type
41:26-41:84
    Type
41:30-41:31
    _b
41:32-41:37
    Type
41:41-41:44
    Nat -> Type -> Type
41:41-41:46
    Type -> Type
41:41-41:52
    Type
41:41-41:84
    Type
41:45-41:46
    _b
41:47-41:52
    Type
41:56-41:59
    Nat -> Type -> Type
41:56-41:61
    Type -> Type
41:56-41:67
    Type
41:56-41:84
    Type
41:60-41:61
    _b
41:62-41:67
    Type
41:71-41:74
    Nat -> Nat -> Type -> Type
41:71-41:76
    Nat -> Type -> Type
41:71-41:78
    Type -> Type
41:71-41:84
    Type | Type
41:75-41:76
    _b | _b
41:75-41:78
    forall a -> Mat 4 4 a -> Type
41:75-41:84
    Mat 4 4 Float -> Type
41:77-41:78
    _b | _b
41:79-41:84
    Type | Type
44:5-44:21
    Type -> Type
44:30-44:35
    Type
44:30-48:37
    Type
45:29-45:33
    Type
45:29-48:37
    Type
46:28-46:31
    Type
46:28-48:37
    Type
47:35-47:36
    Type
47:35-48:37
    Type
48:36-48:37
    Type
52:7-52:13
    Type -> Constraint
57:7-57:16
    Type -> Constraint | Type -> Constraint | Constraint | Type
      -> Constraint | Constraint
57:7-58:12
    Type
57:7-59:11
    Type
58:3-58:7
    forall a . Component a => a
58:11-58:12
    Type | Type
59:3-59:6
    forall a . Component a => a
59:10-59:11
    Type | Type
62:10-62:11
    _b
62:10-89:36
    _b
62:15-62:18
    Type
63:9-63:10
    _b
63:9-90:31
    _b
63:14-63:17
    Type
65:10-65:11
    _b
65:10-89:36
    _b
65:15-65:19
    Type
66:9-66:10
    _b
66:9-90:31
    _b
66:14-66:18
    Type
68:10-68:13
    Float
68:10-89:36
    _b
69:9-69:12
    Float
69:9-90:31
    _b
71:10-71:12
    forall a . a -> a -> VecS a 2
71:10-71:16
    Float -> VecS Float 2
71:10-71:20
    VecS Float 2
71:10-77:28
    forall (a :: Nat) -> VecS Float ('Succ ('Succ a))
71:10-89:36
    VecS _b _a
71:13-71:16
    Float
71:17-71:20
    Float
72:9-72:11
    forall a . a -> a -> VecS a 2
72:9-72:15
    Float -> VecS Float 2
72:9-72:19
    VecS Float 2
72:9-78:27
    forall (a :: Nat) -> VecS Float ('Succ ('Succ a))
72:9-90:31
    VecS _b _a
72:12-72:15
    Float
72:16-72:19
    Float
74:10-74:12
    forall a . a -> a -> a -> VecS a 3
74:10-74:16
    Float -> Float -> VecS Float 3
74:10-74:20
    Float -> VecS Float 3
74:10-74:24
    VecS Float 3
74:10-77:28
    forall (a :: Nat) -> VecS Float ('Succ ('Succ ('Succ a)))
74:13-74:16
    Float
74:17-74:20
    Float
74:21-74:24
    Float
75:9-75:11
    forall a . a -> a -> a -> VecS a 3
75:9-75:15
    Float -> Float -> VecS Float 3
75:9-75:19
    Float -> VecS Float 3
75:9-75:23
    VecS Float 3
75:9-78:27
    forall (a :: Nat) -> VecS Float ('Succ ('Succ ('Succ a)))
75:12-75:15
    Float
75:16-75:19
    Float
75:20-75:23
    Float
77:10-77:12
    forall a . a -> a -> a -> a -> VecS a 4
77:10-77:16
    Float -> Float -> Float -> VecS Float 4
77:10-77:20
    Float -> Float -> VecS Float 4
77:10-77:24
    Float -> VecS Float 4
77:10-77:28
    VecS Float 4
77:13-77:16
    Float
77:17-77:20
    Float
77:21-77:24
    Float
77:25-77:28
    Float
78:9-78:11
    forall a . a -> a -> a -> a -> VecS a 4
78:9-78:15
    Float -> Float -> Float -> VecS Float 4
78:9-78:19
    Float -> Float -> VecS Float 4
78:9-78:23
    Float -> VecS Float 4
78:9-78:27
    VecS Float 4
78:12-78:15
    Float
78:16-78:19
    Float
78:20-78:23
    Float
78:24-78:27
    Float
80:10-80:15
    Bool
81:9-81:13
    Bool
83:10-83:12
    forall a . a -> a -> VecS a 2
83:10-83:18
    Bool -> VecS Bool 2
83:10-83:24
    VecS Bool 2
83:10-89:36
    forall (a :: Nat) -> VecS Bool ('Succ ('Succ a))
83:13-83:18
    Bool
83:19-83:24
    Bool
84:9-84:11
    forall a . a -> a -> VecS a 2
84:9-84:16
    Bool -> VecS Bool 2
84:9-84:21
    VecS Bool 2
84:9-90:31
    forall (a :: Nat) -> VecS Bool ('Succ ('Succ a))
84:12-84:16
    Bool
84:17-84:21
    Bool
86:10-86:12
    forall a . a -> a -> a -> VecS a 3
86:10-86:18
    Bool -> Bool -> VecS Bool 3
86:10-86:24
    Bool -> VecS Bool 3
86:10-86:30
    VecS Bool 3
86:10-89:36
    forall (a :: Nat) -> VecS Bool ('Succ ('Succ ('Succ a)))
86:13-86:18
    Bool
86:19-86:24
    Bool
86:25-86:30
    Bool
87:9-87:11
    forall a . a -> a -> a -> VecS a 3
87:9-87:16
    Bool -> Bool -> VecS Bool 3
87:9-87:21
    Bool -> VecS Bool 3
87:9-87:26
    VecS Bool 3
87:9-90:31
    forall (a :: Nat) -> VecS Bool ('Succ ('Succ ('Succ a)))
87:12-87:16
    Bool
87:17-87:21
    Bool
87:22-87:26
    Bool
89:10-89:12
    forall a . a -> a -> a -> a -> VecS a 4
89:10-89:18
    Bool -> Bool -> Bool -> VecS Bool 4
89:10-89:24
    Bool -> Bool -> VecS Bool 4
89:10-89:30
    Bool -> VecS Bool 4
89:10-89:36
    VecS Bool 4
89:13-89:18
    Bool
89:19-89:24
    Bool
89:25-89:30
    Bool
89:31-89:36
    Bool
90:9-90:11
    forall a . a -> a -> a -> a -> VecS a 4
90:9-90:16
    Bool -> Bool -> Bool -> VecS Bool 4
90:9-90:21
    Bool -> Bool -> VecS Bool 4
90:9-90:26
    Bool -> VecS Bool 4
90:9-90:31
    VecS Bool 4
90:12-90:16
    Bool
90:17-90:21
    Bool
90:22-90:26
    Bool
90:27-90:31
    Bool
92:7-92:15
    Type -> Constraint
97:7-97:15
    Type -> Constraint
118:1-118:8
    forall a . Num (MatVecScalarElem a) => a -> a -> a
118:10-118:17
    forall a . Num (MatVecScalarElem a) => a -> a -> a
118:19-118:26
    forall a . Num (MatVecScalarElem a) => a -> a -> a
118:34-118:37
    Type -> Constraint | Type -> Constraint | Type -> Constraint
118:34-118:58
    Constraint | Constraint | Constraint
118:34-118:73
    Type | Type | Type
118:39-118:55
    Type -> Type | Type -> Type | Type -> Type
118:39-118:57
    Type | Type | Type
118:56-118:57
    _b | _b | _b
118:62-118:63
    Type | Type | Type
118:62-118:73
    Type | Type | Type
118:67-118:68
    Type | Type | Type
118:67-118:73
    Type | Type | Type
118:72-118:73
    Type | Type | Type | Type | Type | Type
119:1-119:9
    forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
119:11-119:19
    forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
119:21-119:29
    forall a b . (a ~ MatVecScalarElem b, Num a) => b -> a -> b
119:34-119:80
    Type | Type | Type | Type | Type | Type
119:35-119:36
    _e | _e | _e
119:35-119:38
    _d -> Constraint | _d -> Constraint | _d -> Constraint
119:35-119:57
    Constraint | Constraint | Constraint
119:37-119:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint
119:39-119:55
    Type -> Type | Type -> Type | Type -> Type
119:39-119:57
    Type | Type | Type
119:56-119:57
    _b | _b | _b
119:59-119:62
    Type -> Constraint | Type -> Constraint | Type -> Constraint
119:59-119:64
    Constraint | Constraint | Constraint
119:59-119:80
    Type | Type | Type
119:63-119:64
    Type | Type | Type
119:69-119:70
    Type | Type | Type
119:69-119:80
    Type | Type | Type
119:74-119:75
    Type | Type | Type
119:74-119:80
    Type | Type | Type
119:79-119:80
    Type | Type | Type | Type | Type | Type
120:1-120:8
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
120:10-120:17
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
120:34-120:75
    Type | Type | Type | Type | Type | Type
120:35-120:38
    Type -> Constraint | Type -> Constraint
120:35-120:40
    Constraint | Constraint
120:39-120:40
    _f | _f
120:42-120:43
    _f | _f
120:42-120:45
    _e -> Constraint | _e -> Constraint
120:42-120:59
    Constraint | Constraint
120:42-120:75
    Type | Type
120:44-120:45
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
120:46-120:55
    Nat -> Type -> Type | Nat -> Type -> Type
120:46-120:57
    Type -> Type | Type -> Type
120:46-120:59
    Type | Type
120:56-120:57
    _c | _c
120:58-120:59
    Type | Type
120:64-120:65
    Type | Type
120:64-120:75
    Type | Type
120:69-120:70
    Type | Type
120:69-120:75
    Type | Type
120:74-120:75
    Type | Type | Type | Type
121:1-121:9
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
121:11-121:19
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
121:34-121:75
    Type | Type | Type | Type | Type | Type
121:35-121:38
    Type -> Constraint | Type -> Constraint
121:35-121:40
    Constraint | Constraint
121:39-121:40
    _f | _f
121:42-121:43
    _f | _f
121:42-121:45
    _e -> Constraint | _e -> Constraint
121:42-121:59
    Constraint | Constraint
121:42-121:75
    Type | Type
121:44-121:45
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
121:46-121:55
    Nat -> Type -> Type | Nat -> Type -> Type
121:46-121:57
    Type -> Type | Type -> Type
121:46-121:59
    Type | Type
121:56-121:57
    _c | _c
121:58-121:59
    Type | Type
121:64-121:65
    Type | Type
121:64-121:75
    Type | Type
121:69-121:70
    Type | Type
121:69-121:75
    Type | Type
121:74-121:75
    Type | Type | Type | Type
122:1-122:8
    forall a . Signed (MatVecScalarElem a) => a -> a
122:34-122:40
    Type -> Constraint
122:34-122:61
    Constraint
122:34-122:71
    Type
122:42-122:58
    Type -> Type
122:42-122:60
    Type
122:59-122:60
    _b
122:65-122:66
    Type
122:65-122:71
    Type
122:70-122:71
    Type | Type
124:1-124:9
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
124:11-124:18
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
124:20-124:28
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b -> b
124:34-124:80
    Type | Type | Type | Type | Type | Type | Type | Type | Type
124:35-124:43
    Type -> Constraint | Type -> Constraint | Type -> Constraint
124:35-124:45
    Constraint | Constraint | Constraint
124:44-124:45
    _f | _f | _f
124:47-124:48
    _f | _f | _f
124:47-124:50
    _e -> Constraint | _e -> Constraint | _e -> Constraint
124:47-124:64
    Constraint | Constraint | Constraint
124:47-124:80
    Type | Type | Type
124:49-124:50
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint
124:51-124:60
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type
124:51-124:62
    Type -> Type | Type -> Type | Type -> Type
124:51-124:64
    Type | Type | Type
124:61-124:62
    _c | _c | _c
124:63-124:64
    Type | Type | Type
124:69-124:70
    Type | Type | Type
124:69-124:80
    Type | Type | Type
124:74-124:75
    Type | Type | Type
124:74-124:80
    Type | Type | Type
124:79-124:80
    Type | Type | Type | Type | Type | Type
125:1-125:10
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
125:12-125:20
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
125:22-125:31
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> a -> b
125:34-125:80
    Type | Type | Type | Type | Type | Type | Type | Type | Type
125:35-125:43
    Type -> Constraint | Type -> Constraint | Type -> Constraint
125:35-125:45
    Constraint | Constraint | Constraint
125:44-125:45
    _f | _f | _f
125:47-125:48
    _f | _f | _f
125:47-125:50
    _e -> Constraint | _e -> Constraint | _e -> Constraint
125:47-125:64
    Constraint | Constraint | Constraint
125:47-125:80
    Type | Type | Type
125:49-125:50
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint
125:51-125:60
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type
125:51-125:62
    Type -> Type | Type -> Type | Type -> Type
125:51-125:64
    Type | Type | Type
125:61-125:62
    _c | _c | _c
125:63-125:64
    Type | Type | Type
125:69-125:70
    Type | Type | Type
125:69-125:80
    Type | Type | Type
125:74-125:75
    Type | Type | Type
125:74-125:80
    Type | Type | Type
125:79-125:80
    Type | Type | Type | Type | Type | Type
126:1-126:9
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> b
126:34-126:75
    Type | Type | Type
126:35-126:43
    Type -> Constraint
126:35-126:45
    Constraint
126:44-126:45
    _f
126:47-126:48
    _f
126:47-126:50
    _e -> Constraint
126:47-126:64
    Constraint
126:47-126:75
    Type
126:49-126:50
    forall a . a -> a -> Constraint
126:51-126:60
    Nat -> Type -> Type
126:51-126:62
    Type -> Type
126:51-126:64
    Type
126:61-126:62
    _c
126:63-126:64
    Type
126:69-126:70
    Type
126:69-126:75
    Type
126:74-126:75
    Type | Type
127:1-127:12
    forall a b (c :: Nat) d
      . (Integral a, b ~ VecScalar c a, d ~ VecScalar c Word) => b -> d -> b
127:14-127:25
    forall a b (c :: Nat) d
      . (Integral a, b ~ VecScalar c a, d ~ VecScalar c Word) => b -> d -> b
127:34-127:102
    Type | Type | Type | Type | Type | Type | Type | Type
127:35-127:43
    Type -> Constraint | Type -> Constraint
127:35-127:45
    Constraint | Constraint
127:44-127:45
    _h | _h
127:47-127:48
    _h | _h
127:47-127:50
    _g -> Constraint | _g -> Constraint
127:47-127:64
    Constraint | Constraint
127:47-127:102
    Type | Type
127:49-127:50
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
127:51-127:60
    Nat -> Type -> Type | Nat -> Type -> Type
127:51-127:62
    Type -> Type | Type -> Type
127:51-127:64
    Type | Type
127:61-127:62
    _e | _e
127:63-127:64
    Type | Type
127:66-127:67
    _e | _e
127:66-127:69
    _d -> Constraint | _d -> Constraint
127:66-127:86
    Constraint | Constraint
127:66-127:102
    Type | Type
127:68-127:69
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
127:70-127:79
    Nat -> Type -> Type | Nat -> Type -> Type
127:70-127:81
    Type -> Type | Type -> Type
127:70-127:86
    Type | Type
127:80-127:81
    Nat | Nat
127:82-127:86
    Type | Type
127:91-127:92
    Type | Type
127:91-127:102
    Type | Type
127:96-127:97
    Type | Type
127:96-127:102
    Type | Type
127:101-127:102
    Type | Type | Type | Type
128:1-128:13
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> Word -> b
128:15-128:27
    forall a b (c :: Nat) . (Integral a, b ~ VecScalar c a) => b -> Word -> b
128:34-128:83
    Type | Type | Type | Type | Type | Type
128:35-128:43
    Type -> Constraint | Type -> Constraint
128:35-128:45
    Constraint | Constraint
128:44-128:45
    _f | _f
128:47-128:48
    _f | _f
128:47-128:50
    _e -> Constraint | _e -> Constraint
128:47-128:64
    Constraint | Constraint
128:47-128:83
    Type | Type
128:49-128:50
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
128:51-128:60
    Nat -> Type -> Type | Nat -> Type -> Type
128:51-128:62
    Type -> Type | Type -> Type
128:51-128:64
    Type | Type
128:61-128:62
    _c | _c
128:63-128:64
    Type | Type
128:69-128:70
    Type | Type
128:69-128:83
    Type | Type
128:74-128:78
    Type | Type
128:74-128:83
    Type | Type
128:82-128:83
    Type | Type | Type | Type
130:1-130:8
    Bool -> Bool -> Bool
130:10-130:16
    Bool -> Bool -> Bool
130:18-130:25
    Bool -> Bool -> Bool
130:34-130:38
    Type | Type | Type
130:42-130:46
    Type | Type | Type
130:42-130:54
    Type | Type | Type
130:50-130:54
    Type | Type | Type | Type | Type | Type
131:1-131:8
    forall a (b :: Nat) . (a ~ VecScalar b Bool) => a -> a
131:47-131:79
    Type | Type
131:48-131:49
    _e
131:48-131:51
    _d -> Constraint
131:48-131:68
    Constraint
131:50-131:51
    forall a . a -> a -> Constraint
131:52-131:61
    Nat -> Type -> Type
131:52-131:63
    Type -> Type
131:52-131:68
    Type
131:62-131:63
    _b
131:64-131:68
    Type
131:73-131:74
    Type
131:73-131:79
    Type
131:78-131:79
    Type | Type
132:1-132:8
    forall (a :: Nat) . VecScalar a Bool -> Bool
132:10-132:17
    forall (a :: Nat) . VecScalar a Bool -> Bool
132:34-132:43
    Nat -> Type -> Type | Nat -> Type -> Type
132:34-132:45
    Type -> Type | Type -> Type
132:34-132:50
    Type | Type
132:34-132:58
    Type | Type
132:44-132:45
    _b | _b
132:46-132:50
    Type | Type
132:54-132:58
    Type | Type | Type | Type
135:1-135:9
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:11-135:20
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:22-135:30
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:32-135:41
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:43-135:51
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:53-135:62
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:64-135:71
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:73-135:81
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:83-135:94
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:96-135:107
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:109-135:116
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:118-135:126
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:128-135:135
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:137-135:145
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:147-135:154
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:156-135:163
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:165-135:173
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:175-135:183
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:185-135:193
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
135:195-135:206
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
136:34-136:67
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
136:35-136:36
    _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e | _e
136:35-136:38
    _d -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint | _d
      -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint | _d
      -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint | _d
      -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint | _d
      -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint
136:35-136:56
    Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint | Constraint
136:37-136:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint
136:39-136:48
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type
136:39-136:50
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type
136:39-136:56
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
136:49-136:50
    _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b | _b
136:51-136:56
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
136:61-136:62
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
136:61-136:67
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
136:66-136:67
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
137:1-137:8
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
137:10-137:19
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
137:34-137:72
    Type | Type | Type | Type
137:35-137:36
    _e | _e
137:35-137:38
    _d -> Constraint | _d -> Constraint
137:35-137:56
    Constraint | Constraint
137:37-137:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
137:39-137:48
    Nat -> Type -> Type | Nat -> Type -> Type
137:39-137:50
    Type -> Type | Type -> Type
137:39-137:56
    Type | Type
137:49-137:50
    _b | _b
137:51-137:56
    Type | Type
137:61-137:62
    Type | Type
137:61-137:72
    Type | Type
137:66-137:67
    Type | Type
137:66-137:72
    Type | Type
137:71-137:72
    Type | Type | Type | Type
139:1-139:10
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
139:12-139:21
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
139:23-139:32
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
139:34-139:47
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
139:49-139:57
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
139:59-139:68
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
140:34-140:67
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
140:35-140:36
    _e | _e | _e | _e | _e | _e
140:35-140:38
    _d -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint | _d
      -> Constraint | _d -> Constraint
140:35-140:56
    Constraint | Constraint | Constraint | Constraint | Constraint | Constraint
140:37-140:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint
140:39-140:48
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type
140:39-140:50
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type
140:39-140:56
    Type | Type | Type | Type | Type | Type
140:49-140:50
    _b | _b | _b | _b | _b | _b
140:51-140:56
    Type | Type | Type | Type | Type | Type
140:61-140:62
    Type | Type | Type | Type | Type | Type
140:61-140:67
    Type | Type | Type | Type | Type | Type
140:66-140:67
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
141:1-141:8
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
141:10-141:17
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b
141:34-141:75
    Type | Type | Type | Type | Type | Type
141:35-141:38
    Type -> Constraint | Type -> Constraint
141:35-141:40
    Constraint | Constraint
141:39-141:40
    _f | _f
141:42-141:43
    _f | _f
141:42-141:45
    _e -> Constraint | _e -> Constraint
141:42-141:59
    Constraint | Constraint
141:42-141:75
    Type | Type
141:44-141:45
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
141:46-141:55
    Nat -> Type -> Type | Nat -> Type -> Type
141:46-141:57
    Type -> Type | Type -> Type
141:46-141:59
    Type | Type
141:56-141:57
    _c | _c
141:58-141:59
    Type | Type
141:64-141:65
    Type | Type
141:64-141:75
    Type | Type
141:69-141:70
    Type | Type
141:69-141:75
    Type | Type
141:74-141:75
    Type | Type | Type | Type
142:1-142:9
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
142:11-142:19
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> b
142:34-142:75
    Type | Type | Type | Type | Type | Type
142:35-142:38
    Type -> Constraint | Type -> Constraint
142:35-142:40
    Constraint | Constraint
142:39-142:40
    _f | _f
142:42-142:43
    _f | _f
142:42-142:45
    _e -> Constraint | _e -> Constraint
142:42-142:59
    Constraint | Constraint
142:42-142:75
    Type | Type
142:44-142:45
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
142:46-142:55
    Nat -> Type -> Type | Nat -> Type -> Type
142:46-142:57
    Type -> Type | Type -> Type
142:46-142:59
    Type | Type
142:56-142:57
    _c | _c
142:58-142:59
    Type | Type
142:64-142:65
    Type | Type
142:64-142:75
    Type | Type
142:69-142:70
    Type | Type
142:69-142:75
    Type | Type
142:74-142:75
    Type | Type | Type | Type
143:1-143:10
    forall a (b :: Nat) c . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c
143:12-143:21
    forall a (b :: Nat) c . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> c
143:34-143:89
    Type | Type | Type | Type | Type | Type
143:35-143:36
    _g | _g
143:35-143:38
    _f -> Constraint | _f -> Constraint
143:35-143:56
    Constraint | Constraint
143:37-143:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
143:39-143:48
    Nat -> Type -> Type | Nat -> Type -> Type
143:39-143:50
    Type -> Type | Type -> Type
143:39-143:56
    Type | Type
143:49-143:50
    _d | _d
143:51-143:56
    Type | Type
143:58-143:59
    _d | _d
143:58-143:61
    _c -> Constraint | _c -> Constraint
143:58-143:78
    Constraint | Constraint
143:58-143:89
    Type | Type
143:60-143:61
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
143:62-143:71
    Nat -> Type -> Type | Nat -> Type -> Type
143:62-143:73
    Type -> Type | Type -> Type
143:62-143:78
    Type | Type
143:72-143:73
    Nat | Nat
143:74-143:78
    Type | Type
143:83-143:84
    Type | Type
143:83-143:89
    Type | Type
143:88-143:89
    Type | Type | Type | Type
144:1-144:8
    forall a b (c :: Nat) . (Signed a, b ~ VecScalar c a) => b -> b
144:10-144:18
    forall a b (c :: Nat) . (Signed a, b ~ VecScalar c a) => b -> b
144:34-144:73
    Type | Type | Type | Type | Type | Type
144:35-144:41
    Type -> Constraint | Type -> Constraint
144:35-144:43
    Constraint | Constraint
144:42-144:43
    _f | _f
144:45-144:46
    _f | _f
144:45-144:48
    _e -> Constraint | _e -> Constraint
144:45-144:62
    Constraint | Constraint
144:45-144:73
    Type | Type
144:47-144:48
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
144:49-144:58
    Nat -> Type -> Type | Nat -> Type -> Type
144:49-144:60
    Type -> Type | Type -> Type
144:49-144:62
    Type | Type
144:59-144:60
    _c | _c
144:61-144:62
    Type | Type
144:67-144:68
    Type | Type
144:67-144:73
    Type | Type
144:72-144:73
    Type | Type | Type | Type
145:1-145:9
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> (a, a)
145:34-145:72
    Type | Type
145:35-145:36
    _e
145:35-145:38
    _d -> Constraint
145:35-145:56
    Constraint
145:37-145:38
    forall a . a -> a -> Constraint
145:39-145:48
    Nat -> Type -> Type
145:39-145:50
    Type -> Type
145:39-145:56
    Type
145:49-145:50
    _b
145:51-145:56
    Type
145:61-145:62
    Type
145:61-145:72
    Type
145:66-145:72
    Type | Type
145:67-145:68
    Type
145:67-145:71
    [Type]
145:70-145:71
    Type | [Type]
146:1-146:10
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> b -> b -> b
146:34-146:80
    Type | Type | Type
146:35-146:38
    Type -> Constraint
146:35-146:40
    Constraint
146:39-146:40
    _f
146:42-146:43
    _f
146:42-146:45
    _e -> Constraint
146:42-146:59
    Constraint
146:42-146:80
    Type
146:44-146:45
    forall a . a -> a -> Constraint
146:46-146:55
    Nat -> Type -> Type
146:46-146:57
    Type -> Type
146:46-146:59
    Type
146:56-146:57
    _c
146:58-146:59
    Type
146:64-146:65
    Type
146:64-146:80
    Type
146:69-146:70
    Type
146:69-146:80
    Type
146:74-146:75
    Type
146:74-146:80
    Type
146:79-146:80
    Type | Type
147:1-147:11
    forall a b (c :: Nat) . (Num a, b ~ VecScalar c a) => b -> a -> a -> b
147:34-147:80
    Type | Type | Type
147:35-147:38
    Type -> Constraint
147:35-147:40
    Constraint
147:39-147:40
    _f
147:42-147:43
    _f
147:42-147:45
    _e -> Constraint
147:42-147:59
    Constraint
147:42-147:80
    Type
147:44-147:45
    forall a . a -> a -> Constraint
147:46-147:55
    Nat -> Type -> Type
147:46-147:57
    Type -> Type
147:46-147:59
    Type
147:56-147:57
    _c
147:58-147:59
    Type
147:64-147:65
    Type
147:64-147:80
    Type
147:69-147:70
    Type
147:69-147:80
    Type
147:74-147:75
    Type
147:74-147:80
    Type
147:79-147:80
    Type | Type
148:1-148:8
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
148:34-148:77
    Type | Type
148:35-148:36
    _e
148:35-148:38
    _d -> Constraint
148:35-148:56
    Constraint
148:37-148:38
    forall a . a -> a -> Constraint
148:39-148:48
    Nat -> Type -> Type
148:39-148:50
    Type -> Type
148:39-148:56
    Type
148:49-148:50
    _b
148:51-148:56
    Type
148:61-148:62
    Type
148:61-148:77
    Type
148:66-148:67
    Type
148:66-148:77
    Type
148:71-148:72
    Type
148:71-148:77
    Type
148:76-148:77
    Type | Type
149:1-149:9
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float -> a
149:34-149:81
    Type | Type
149:35-149:36
    _e
149:35-149:38
    _d -> Constraint
149:35-149:56
    Constraint
149:37-149:38
    forall a . a -> a -> Constraint
149:39-149:48
    Nat -> Type -> Type
149:39-149:50
    Type -> Type
149:39-149:56
    Type
149:49-149:50
    _b
149:51-149:56
    Type
149:61-149:62
    Type
149:61-149:81
    Type
149:66-149:67
    Type
149:66-149:81
    Type
149:71-149:76
    Type
149:71-149:81
    Type
149:80-149:81
    Type | Type
150:1-150:9
    forall a (b :: Nat) c
      . (a ~ VecScalar b Float, c ~ VecScalar b Bool) => a -> a -> c -> a
150:34-150:99
    Type | Type | Type
150:35-150:36
    _g
150:35-150:38
    _f -> Constraint
150:35-150:56
    Constraint
150:37-150:38
    forall a . a -> a -> Constraint
150:39-150:48
    Nat -> Type -> Type
150:39-150:50
    Type -> Type
150:39-150:56
    Type
150:49-150:50
    _d
150:51-150:56
    Type
150:58-150:59
    _d
150:58-150:61
    _c -> Constraint
150:58-150:78
    Constraint
150:58-150:99
    Type
150:60-150:61
    forall a . a -> a -> Constraint
150:62-150:71
    Nat -> Type -> Type
150:62-150:73
    Type -> Type
150:62-150:78
    Type
150:72-150:73
    Nat
150:74-150:78
    Type
150:83-150:84
    Type
150:83-150:99
    Type
150:88-150:89
    Type
150:88-150:99
    Type
150:93-150:94
    Type
150:93-150:99
    Type
150:98-150:99
    Type | Type
151:1-151:9
    forall a (b :: Nat) . (a ~ VecS Float b) => a -> a -> a
151:34-151:66
    Type | Type
151:35-151:36
    _e
151:35-151:38
    _d -> Constraint
151:35-151:50
    Constraint
151:37-151:38
    forall a . a -> a -> Constraint
151:39-151:42
    Nat -> Type -> Type
151:39-151:44
    Type -> Type
151:39-151:50
    Type
151:43-151:44
    _b
151:45-151:50
    Type
151:55-151:56
    Type
151:55-151:66
    Type
151:60-151:61
    Type
151:60-151:66
    Type
151:65-151:66
    Type | Type
152:1-152:10
    forall a (b :: Nat) . (a ~ VecScalar b Float) => Float -> a -> a
152:34-152:76
    Type | Type
152:35-152:36
    _e
152:35-152:38
    _d -> Constraint
152:35-152:56
    Constraint
152:37-152:38
    forall a . a -> a -> Constraint
152:39-152:48
    Nat -> Type -> Type
152:39-152:50
    Type -> Type
152:39-152:56
    Type
152:49-152:50
    _b
152:51-152:56
    Type
152:61-152:66
    Type
152:61-152:76
    Type
152:70-152:71
    Type
152:70-152:76
    Type
152:75-152:76
    Type | Type
153:1-153:15
    forall a (b :: Nat) . (a ~ VecS Float b) => a -> a -> a -> a
153:34-153:71
    Type | Type
153:35-153:36
    _e
153:35-153:38
    _d -> Constraint
153:35-153:50
    Constraint
153:37-153:38
    forall a . a -> a -> Constraint
153:39-153:42
    Nat -> Type -> Type
153:39-153:44
    Type -> Type
153:39-153:50
    Type
153:43-153:44
    _b
153:45-153:50
    Type
153:55-153:56
    Type
153:55-153:71
    Type
153:60-153:61
    Type
153:60-153:71
    Type
153:65-153:66
    Type
153:65-153:71
    Type
153:70-153:71
    Type | Type
154:1-154:16
    forall a (b :: Nat) . (a ~ VecScalar b Float) => Float -> Float -> a -> a
154:34-154:85
    Type | Type
154:35-154:36
    _e
154:35-154:38
    _d -> Constraint
154:35-154:56
    Constraint
154:37-154:38
    forall a . a -> a -> Constraint
154:39-154:48
    Nat -> Type -> Type
154:39-154:50
    Type -> Type
154:39-154:56
    Type
154:49-154:50
    _b
154:51-154:56
    Type
154:61-154:66
    Type
154:61-154:85
    Type
154:70-154:75
    Type
154:70-154:85
    Type
154:79-154:80
    Type
154:79-154:85
    Type
154:84-154:85
    Type | Type
157:1-157:19
    forall (a :: Nat) . VecScalar a Float -> VecScalar a Int
157:34-157:43
    Nat -> Type -> Type
157:34-157:45
    Type -> Type
157:34-157:51
    Type
157:34-157:70
    Type
157:44-157:45
    _b
157:46-157:51
    Type
157:55-157:64
    Nat -> Type -> Type
157:55-157:66
    Type -> Type
157:55-157:70
    Type | Type
157:65-157:66
    Nat
157:67-157:70
    Type
158:1-158:20
    forall (a :: Nat) . VecScalar a Float -> VecScalar a Word
158:34-158:43
    Nat -> Type -> Type
158:34-158:45
    Type -> Type
158:34-158:51
    Type
158:34-158:71
    Type
158:44-158:45
    _b
158:46-158:51
    Type
158:55-158:64
    Nat -> Type -> Type
158:55-158:66
    Type -> Type
158:55-158:71
    Type | Type
158:65-158:66
    Nat
158:67-158:71
    Type
159:1-159:19
    forall (a :: Nat) . VecScalar a Int -> VecScalar a Float
159:34-159:43
    Nat -> Type -> Type
159:34-159:45
    Type -> Type
159:34-159:49
    Type
159:34-159:72
    Type
159:44-159:45
    _b
159:46-159:49
    Type
159:55-159:64
    Nat -> Type -> Type
159:55-159:66
    Type -> Type
159:55-159:72
    Type | Type
159:65-159:66
    Nat
159:67-159:72
    Type
160:1-160:20
    forall (a :: Nat) . VecScalar a Word -> VecScalar a Float
160:34-160:43
    Nat -> Type -> Type
160:34-160:45
    Type -> Type
160:34-160:50
    Type
160:34-160:72
    Type
160:44-160:45
    _b
160:46-160:50
    Type
160:55-160:64
    Nat -> Type -> Type
160:55-160:66
    Type -> Type
160:55-160:72
    Type | Type
160:65-160:66
    Nat
160:67-160:72
    Type
162:1-162:11
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> Float
162:34-162:71
    Type | Type
162:35-162:36
    _e
162:35-162:38
    _d -> Constraint
162:35-162:56
    Constraint
162:37-162:38
    forall a . a -> a -> Constraint
162:39-162:48
    Nat -> Type -> Type
162:39-162:50
    Type -> Type
162:39-162:56
    Type
162:49-162:50
    _b
162:51-162:56
    Type
162:61-162:62
    Type
162:61-162:71
    Type
162:66-162:71
    Type | Type
163:1-163:13
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float
163:15-163:22
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> Float
163:34-163:76
    Type | Type | Type | Type
163:35-163:36
    _e | _e
163:35-163:38
    _d -> Constraint | _d -> Constraint
163:35-163:56
    Constraint | Constraint
163:37-163:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
163:39-163:48
    Nat -> Type -> Type | Nat -> Type -> Type
163:39-163:50
    Type -> Type | Type -> Type
163:39-163:56
    Type | Type
163:49-163:50
    _b | _b
163:51-163:56
    Type | Type
163:61-163:62
    Type | Type
163:61-163:76
    Type | Type
163:66-163:67
    Type | Type
163:66-163:76
    Type | Type
163:71-163:76
    Type | Type | Type | Type
164:1-164:10
    forall a . (a ~ VecS Float 3) => a -> a -> a
164:34-164:72
    Type
164:35-164:36
    _c
164:35-164:38
    _b -> Constraint
164:35-164:56
    Constraint
164:37-164:38
    forall a . a -> a -> Constraint
164:39-164:48
    Nat -> Type -> Type
164:39-164:50
    Type -> Type
164:39-164:56
    Type
164:49-164:50
    _b
164:51-164:56
    Type
164:61-164:62
    Type
164:61-164:72
    Type
164:66-164:67
    Type
164:66-164:72
    Type
164:71-164:72
    Type | Type
165:1-165:14
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
165:34-165:67
    Type | Type
165:35-165:36
    _e
165:35-165:38
    _d -> Constraint
165:35-165:56
    Constraint
165:37-165:38
    forall a . a -> a -> Constraint
165:39-165:48
    Nat -> Type -> Type
165:39-165:50
    Type -> Type
165:39-165:56
    Type
165:49-165:50
    _b
165:51-165:56
    Type
165:61-165:62
    Type
165:61-165:67
    Type
165:66-165:67
    Type | Type
166:1-166:16
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
166:18-166:29
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a -> a
166:34-166:77
    Type | Type | Type | Type
166:35-166:36
    _e | _e
166:35-166:38
    _d -> Constraint | _d -> Constraint
166:35-166:56
    Constraint | Constraint
166:37-166:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
166:39-166:48
    Nat -> Type -> Type | Nat -> Type -> Type
166:39-166:50
    Type -> Type | Type -> Type
166:39-166:56
    Type | Type
166:49-166:50
    _b | _b
166:51-166:56
    Type | Type
166:61-166:62
    Type | Type
166:61-166:77
    Type | Type
166:66-166:67
    Type | Type
166:66-166:77
    Type | Type
166:71-166:72
    Type | Type
166:71-166:77
    Type | Type
166:76-166:77
    Type | Type | Type | Type
167:1-167:12
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a -> a
167:34-167:72
    Type | Type
167:35-167:36
    _e
167:35-167:38
    _d -> Constraint
167:35-167:56
    Constraint
167:37-167:38
    forall a . a -> a -> Constraint
167:39-167:48
    Nat -> Type -> Type
167:39-167:50
    Type -> Type
167:39-167:56
    Type
167:49-167:50
    _b
167:51-167:56
    Type
167:61-167:62
    Type
167:61-167:72
    Type
167:66-167:67
    Type
167:66-167:72
    Type
167:71-167:72
    Type | Type
169:1-169:14
    forall (a :: Nat) (b :: Nat) c . Mat a b c -> Mat b a c
169:34-169:37
    Nat -> Nat -> Type -> Type
169:34-169:39
    Nat -> Type -> Type
169:34-169:41
    Type -> Type
169:34-169:43
    Type
169:34-169:56
    Type | Type | Type
169:38-169:39
    _f
169:40-169:41
    _d
169:42-169:43
    _b
169:47-169:50
    Nat -> Nat -> Type -> Type
169:47-169:52
    Nat -> Type -> Type
169:47-169:54
    Type -> Type
169:47-169:56
    Type | Type
169:51-169:52
    Nat
169:53-169:54
    Nat
169:55-169:56
    Type
170:1-170:16
    forall (a :: Nat) b . Mat a a b -> Float
170:34-170:37
    Nat -> Nat -> Type -> Type
170:34-170:39
    Nat -> Type -> Type
170:34-170:41
    Type -> Type
170:34-170:43
    Type
170:34-170:52
    Type | Type
170:38-170:39
    _d
170:40-170:41
    Nat
170:42-170:43
    _b
170:47-170:52
    Type | Type
171:1-171:12
    forall (a :: Nat) b . Mat a a b -> Mat a a b
171:34-171:37
    Nat -> Nat -> Type -> Type
171:34-171:39
    Nat -> Type -> Type
171:34-171:41
    Type -> Type
171:34-171:43
    Type
171:34-171:56
    Type | Type
171:38-171:39
    _d
171:40-171:41
    Nat
171:42-171:43
    _b
171:47-171:50
    Nat -> Nat -> Type -> Type
171:47-171:52
    Nat -> Type -> Type
171:47-171:54
    Type -> Type
171:47-171:56
    Type | Type
171:51-171:52
    Nat
171:53-171:54
    Nat
171:55-171:56
    Type
172:1-172:17
    forall (a :: Nat) b (c :: Nat) . Vec a b -> Vec c b -> Mat c a b
172:34-172:37
    Nat -> Type -> Type
172:34-172:39
    Type -> Type
172:34-172:41
    Type
172:34-172:69
    Type | Type | Type
172:38-172:39
    _f
172:40-172:41
    _d
172:47-172:50
    Nat -> Type -> Type
172:47-172:52
    Type -> Type
172:47-172:54
    Type
172:47-172:69
    Type
172:51-172:52
    _c
172:53-172:54
    Type
172:60-172:63
    Nat -> Nat -> Type -> Type
172:60-172:65
    Nat -> Type -> Type
172:60-172:67
    Type -> Type
172:60-172:69
    Type | Type
172:64-172:65
    Nat
172:66-172:67
    Nat
172:68-172:69
    Type
173:1-173:14
    forall (a :: Nat) (b :: Nat) c . Mat a b c -> Vec b c -> Vec a c
173:34-173:37
    Nat -> Nat -> Type -> Type
173:34-173:39
    Nat -> Type -> Type
173:34-173:41
    Type -> Type
173:34-173:43
    Type
173:34-173:67
    Type | Type | Type
173:38-173:39
    _f
173:40-173:41
    _d
173:42-173:43
    _b
173:47-173:50
    Nat -> Type -> Type
173:47-173:52
    Type -> Type
173:47-173:54
    Type
173:47-173:67
    Type
173:51-173:52
    Nat
173:53-173:54
    Type
173:60-173:63
    Nat -> Type -> Type
173:60-173:65
    Type -> Type
173:60-173:67
    Type | Type
173:64-173:65
    Nat
173:66-173:67
    Type
174:1-174:14
    forall (a :: Nat) b (c :: Nat) . Vec a b -> Mat a c b -> Vec c b
174:34-174:37
    Nat -> Type -> Type
174:34-174:39
    Type -> Type
174:34-174:41
    Type
174:34-174:67
    Type | Type | Type
174:38-174:39
    _f
174:40-174:41
    _d
174:47-174:50
    Nat -> Nat -> Type -> Type
174:47-174:52
    Nat -> Type -> Type
174:47-174:54
    Type -> Type
174:47-174:56
    Type
174:47-174:67
    Type
174:51-174:52
    Nat
174:53-174:54
    _c
174:55-174:56
    Type
174:60-174:63
    Nat -> Type -> Type
174:60-174:65
    Type -> Type
174:60-174:67
    Type | Type
174:64-174:65
    Nat
174:66-174:67
    Type
175:1-175:14
    forall (a :: Nat) (b :: Nat) c (d :: Nat) . Mat a b c -> Mat b d c -> Mat a d c
175:34-175:37
    Nat -> Nat -> Type -> Type
175:34-175:39
    Nat -> Type -> Type
175:34-175:41
    Type -> Type
175:34-175:43
    Type
175:34-175:69
    Type | Type | Type | Type
175:38-175:39
    _h
175:40-175:41
    _f
175:42-175:43
    _d
175:47-175:50
    Nat -> Nat -> Type -> Type
175:47-175:52
    Nat -> Type -> Type
175:47-175:54
    Type -> Type
175:47-175:56
    Type
175:47-175:69
    Type
175:51-175:52
    Nat
175:53-175:54
    _c
175:55-175:56
    Type
175:60-175:63
    Nat -> Nat -> Type -> Type
175:60-175:65
    Nat -> Type -> Type
175:60-175:67
    Type -> Type
175:60-175:69
    Type | Type
175:64-175:65
    Nat
175:66-175:67
    Nat
175:68-175:69
    Type
177:1-177:13
    forall a (b :: Nat) c d
      . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
177:15-177:32
    forall a (b :: Nat) c d
      . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
177:34-177:49
    forall a (b :: Nat) c d
      . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
177:51-177:71
    forall a (b :: Nat) c d
      . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
177:73-177:83
    forall a (b :: Nat) c d
      . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
177:85-177:98
    forall a (b :: Nat) c d
      . (Num c, a ~ VecScalar b c, d ~ VecScalar b Bool) => a -> a -> d
178:51-178:114
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
178:52-178:55
    Type -> Constraint | Type -> Constraint | Type -> Constraint | Type
      -> Constraint | Type -> Constraint | Type -> Constraint
178:52-178:57
    Constraint | Constraint | Constraint | Constraint | Constraint | Constraint
178:56-178:57
    _d | _d | _d | _d | _d | _d
178:59-178:60
    _i | _i | _i | _i | _i | _i
178:59-178:62
    _h -> Constraint | _h -> Constraint | _h -> Constraint | _h -> Constraint | _h
      -> Constraint | _h -> Constraint
178:59-178:76
    Constraint | Constraint | Constraint | Constraint | Constraint | Constraint
178:59-178:114
    Type | Type | Type | Type | Type | Type
178:61-178:62
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint
178:63-178:72
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type
178:63-178:74
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type
178:63-178:76
    Type | Type | Type | Type | Type | Type
178:73-178:74
    _f | _f | _f | _f | _f | _f
178:75-178:76
    Type | Type | Type | Type | Type | Type
178:78-178:79
    _e | _e | _e | _e | _e | _e
178:78-178:81
    _d -> Constraint | _d -> Constraint | _d -> Constraint | _d -> Constraint | _d
      -> Constraint | _d -> Constraint
178:78-178:98
    Constraint | Constraint | Constraint | Constraint | Constraint | Constraint
178:78-178:114
    Type | Type | Type | Type | Type | Type
178:80-178:81
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint | forall a . a -> a -> Constraint
178:82-178:91
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type
178:82-178:93
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type
178:82-178:98
    Type | Type | Type | Type | Type | Type
178:92-178:93
    Nat | Nat | Nat | Nat | Nat | Nat
178:94-178:98
    Type | Type | Type | Type | Type | Type
178:103-178:104
    Type | Type | Type | Type | Type | Type
178:103-178:114
    Type | Type | Type | Type | Type | Type
178:108-178:109
    Type | Type | Type | Type | Type | Type
178:108-178:114
    Type | Type | Type | Type | Type | Type
178:113-178:114
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
179:1-179:10
    forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
179:12-179:24
    forall a b . (b ~ MatVecScalarElem a) => a -> a -> Bool
179:47-179:89
    Type | Type | Type | Type
179:48-179:49
    _c | _c
179:48-179:51
    _b -> Constraint | _b -> Constraint
179:48-179:70
    Constraint | Constraint
179:50-179:51
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint
179:52-179:68
    Type -> Type | Type -> Type
179:52-179:70
    Type | Type
179:69-179:70
    _c | _c
179:75-179:76
    Type | Type
179:75-179:89
    Type | Type
179:80-179:81
    Type | Type
179:80-179:89
    Type | Type
179:85-179:89
    Type | Type | Type | Type
181:1-181:9
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
181:11-181:19
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
181:21-181:31
    forall a (b :: Nat) . (a ~ VecScalar b Float) => a -> a
182:34-182:67
    Type | Type | Type | Type | Type | Type
182:35-182:36
    _e | _e | _e
182:35-182:38
    _d -> Constraint | _d -> Constraint | _d -> Constraint
182:35-182:56
    Constraint | Constraint | Constraint
182:37-182:38
    forall a . a -> a -> Constraint | forall a . a -> a -> Constraint | forall a
      . a -> a -> Constraint
182:39-182:48
    Nat -> Type -> Type | Nat -> Type -> Type | Nat -> Type -> Type
182:39-182:50
    Type -> Type | Type -> Type | Type -> Type
182:39-182:56
    Type | Type | Type
182:49-182:50
    _b | _b | _b
182:51-182:56
    Type | Type | Type
182:61-182:62
    Type | Type | Type
182:61-182:67
    Type | Type | Type
182:66-182:67
    Type | Type | Type | Type | Type | Type
184:1-184:11
    forall (a :: Nat) . VecScalar a Float -> Float
184:34-184:43
    Nat -> Type -> Type
184:34-184:45
    Type -> Type
184:34-184:51
    Type
184:34-184:60
    Type
184:44-184:45
    _b
184:46-184:51
    Type
184:55-184:60
    Type | Type
185:1-185:11
    forall (a :: Nat) . VecScalar a Float -> Vec 2 Float
185:34-185:43
    Nat -> Type -> Type
185:34-185:45
    Type -> Type
185:34-185:51
    Type
185:34-185:66
    Type
185:44-185:45
    _b
185:46-185:51
    Type
185:55-185:58
    Nat -> Type -> Type
185:55-185:60
    Type -> Type
185:55-185:66
    Type | Type
185:59-185:60
    _b
185:61-185:66
    Type
186:1-186:11
    forall (a :: Nat) . VecScalar a Float -> Vec 3 Float
186:34-186:43
    Nat -> Type -> Type
186:34-186:45
    Type -> Type
186:34-186:51
    Type
186:34-186:66
    Type
186:44-186:45
    _b
186:46-186:51
    Type
186:55-186:58
    Nat -> Type -> Type
186:55-186:60
    Type -> Type
186:55-186:66
    Type | Type
186:59-186:60
    _b
186:61-186:66
    Type
187:1-187:11
    forall (a :: Nat) . VecScalar a Float -> Vec 4 Float
187:34-187:43
    Nat -> Type -> Type
187:34-187:45
    Type -> Type
187:34-187:51
    Type
187:34-187:66
    Type
187:44-187:45
    _b
187:46-187:51
    Type
187:55-187:58
    Nat -> Type -> Type
187:55-187:60
    Type -> Type
187:55-187:66
    Type | Type
187:59-187:60
    _b
187:61-187:66
    Type
201:1-201:5
    forall a . [a] -> a
201:15-201:16
    _d
203:6-203:8
    forall a . [a] -> [a] -> [a]
203:14-203:16
    _d
203:14-204:26
    [_a] -> [_a]
204:14-204:15
    _d
204:14-204:17
    [_c] -> [_c]
204:14-204:26
    [_c]
204:16-204:17
    forall a . a -> [a] -> [a]
204:18-204:20
    [_f]
204:21-204:23
    _h
204:24-204:26
    [_g]
206:1-206:6
    forall a b . (b -> a -> a) -> a -> [b] -> a
206:16-206:17
    _f
206:16-207:39
    [_b] -> _f
207:21-207:22
    _i
207:23-207:24
    _f
207:26-207:31
    _n
207:32-207:33
    _j -> _g
207:34-207:35
    _o
207:36-207:38
    [_k]
209:1-209:7
    forall a . [[a]] -> [a]
209:10-209:15
    forall a b . (b -> a -> a) -> a -> [b] -> a
209:10-209:20
    [_a] -> [[_a]] -> [_a]
209:10-209:23
    [[_a]] -> [_a]
209:16-209:20
    forall a . [a] -> [a] -> [a]
209:21-209:23
    forall a . [a]
211:1-211:4
    forall a b . (a -> b) -> [a] -> [b]
211:16-211:18
    forall a . [a]
211:16-212:30
    [_b] -> [_a]
212:16-212:17
    _i
212:16-212:21
    [_a] -> [_a]
212:16-212:30
    [_c]
212:18-212:19
    _h
212:20-212:21
    forall a . a -> [a] -> [a]
212:22-212:25
    _i
212:26-212:27
    _g -> _f
212:28-212:30
    [_h]
214:14-214:38
    Type | Type
214:15-214:16
    _d
214:20-214:23
    Type | Type
214:21-214:22
    _c
214:28-214:31
    Type
214:28-214:38
    Type
214:29-214:30
    Type
214:35-214:38
    Type | Type
214:36-214:37
    Type
215:1-215:10
    forall a b . (a -> [b]) -> [a] -> [b]
215:17-215:23
    forall a . [[a]] -> [a]
215:17-215:33
    [_c]
215:25-215:28
    forall a b . (a -> b) -> [a] -> [b]
215:25-215:30
    [_e] -> [[_d]]
215:25-215:32
    [[_c]]
215:29-215:30
    _g -> [_f]
215:31-215:32
    [_d]
217:1-217:4
    forall a . [a] -> Int
217:10-217:11
    _b
217:10-218:35
    [_b] -> Int
218:14-218:15
    _b
218:14-218:28
    Int -> Int
218:14-218:35
    Int
218:16-218:28
    Int -> Int -> Int
218:29-218:32
    _h
218:33-218:35
    [_g]
222:6-222:11
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
222:6-222:13
    Type | Type | Type | Type
222:6-224:11
    Type | Type | Type
222:6-224:13
    Type
222:12-222:13
    Type | Type
223:7-223:14
    forall a . Maybe a | Maybe _b
224:7-224:11
    forall a . a -> Maybe a | Maybe _d | Type | Type
224:12-224:13
    Type
227:6-227:12
    Nat -> Type -> Type | Nat -> Type -> Type | Nat
      -> Type -> Type | Type | Type | Type
227:19-227:22
    Type | Type
231:6-231:19
    Type | Type | Type | Type | Type | Type | Type | Type | Type
231:6-236:20
    Type | Type | Type | Type | Type
232:7-232:15
    PrimitiveType
233:7-233:11
    PrimitiveType
234:7-234:12
    PrimitiveType
235:7-235:24
    PrimitiveType
236:7-236:20
    PrimitiveType
238:6-238:15
    Type -> PrimitiveType -> Type | Type -> PrimitiveType -> Type | Type | Type
      -> PrimitiveType -> Type | Type | Type
238:6-241:56
    Type | Type | Type | Type
238:21-238:34
    Type
238:21-238:42
    Type
238:38-238:42
    Type | Type
239:5-239:14
    forall a . a -> Primitive a 'Point | Primitive _c 'Point
239:5-239:53
    Type | Type
239:21-239:22
    Type
239:21-239:53
    Type
239:36-239:45
    Type -> PrimitiveType -> Type
239:36-239:47
    PrimitiveType -> Type
239:36-239:53
    Type | Type
239:46-239:47
    Type
239:48-239:53
    PrimitiveType | PrimitiveType
240:5-240:13
    forall a . a -> a -> Primitive a 'Line | Primitive _e 'Line
240:5-240:52
    Type | Type | Type
240:21-240:22
    Type
240:21-240:52
    Type
240:26-240:27
    Type
240:26-240:52
    Type
240:36-240:45
    Type -> PrimitiveType -> Type
240:36-240:47
    PrimitiveType -> Type
240:36-240:52
    Type | Type
240:46-240:47
    Type
240:48-240:52
    PrimitiveType | PrimitiveType
241:5-241:17
    forall a . a -> a -> a -> Primitive a 'Triangle | Primitive _g 'Triangle
241:5-241:56
    Type | Type | Type | Type
241:21-241:22
    Type
241:21-241:56
    Type
241:26-241:27
    Type
241:26-241:56
    Type
241:31-241:32
    Type
241:31-241:56
    Type
241:36-241:45
    Type -> PrimitiveType -> Type
241:36-241:47
    PrimitiveType -> Type
241:36-241:56
    Type | Type
241:46-241:47
    Type
241:48-241:56
    PrimitiveType | PrimitiveType
243:1-243:13
    forall a b (c :: PrimitiveType) . (a -> b) -> Primitive a c -> Primitive b c
243:17-243:59
    Type | Type | Type
243:18-243:19
    _f
243:23-243:24
    _e | Type
243:29-243:38
    Type -> PrimitiveType -> Type
243:29-243:40
    PrimitiveType -> Type
243:29-243:42
    Type
243:29-243:59
    Type
243:39-243:40
    Type
243:41-243:42
    _c
243:46-243:55
    Type -> PrimitiveType -> Type
243:46-243:57
    PrimitiveType -> Type
243:46-243:59
    Type | Type
243:56-243:57
    Type
243:58-243:59
    PrimitiveType
250:6-250:21
    PrimitiveType -> Type -> Type
250:28-250:43
    Type
250:29-250:38
    Type -> PrimitiveType -> Type
250:29-250:40
    PrimitiveType -> Type
250:29-250:42
    Type
250:39-250:40
    _b
250:41-250:42
    _c
252:18-252:72
    Type | Type | Type
252:19-252:20
    _f
252:24-252:25
    _e | Type
252:30-252:45
    PrimitiveType -> Type -> Type
252:30-252:47
    Type -> Type
252:30-252:49
    Type
252:30-252:72
    Type
252:46-252:47
    _c
252:48-252:49
    Type
252:53-252:68
    PrimitiveType -> Type -> Type
252:53-252:70
    Type -> Type
252:53-252:72
    Type | Type
252:69-252:70
    PrimitiveType
252:71-252:72
    Type
253:1-253:14
    forall a b (c :: PrimitiveType) . (a -> b) -> [Primitive a c] -> [Primitive b c]
253:19-253:22
    forall a b . (a -> b) -> [a] -> [b]
253:19-253:39
    [Primitive _e _a] -> [Primitive _d _a]
253:24-253:36
    forall a b (c :: PrimitiveType) . (a -> b) -> Primitive a c -> Primitive b c
253:24-253:38
    Primitive _g _a -> Primitive _f _a
253:37-253:38
    _i -> _h
255:30-255:38
    Type -> Type
255:45-255:46
    Type
260:1-260:12
    forall (a :: PrimitiveType) (b :: [Type]) (c :: [Type])
      . (b ~ (map ListElem c :: [Type])) => HList c -> PrimitiveStream a (HList b)
260:32-260:119
    Type | Type | Type
260:56-260:57
    _e
260:56-260:59
    _d -> Constraint
260:56-260:75
    Constraint
260:58-260:59
    forall a . a -> a -> Constraint
260:60-260:63
    forall a b . (a -> b) -> [a] -> [b]
260:60-260:72
    [Type] -> [Type]
260:60-260:75
    [Type]
260:64-260:72
    Type -> Type
260:73-260:75
    _b
260:80-260:85
    [Type] -> Type
260:80-260:88
    Type
260:80-260:119
    Type
260:86-260:88
    [Type]
260:92-260:107
    PrimitiveType -> Type -> Type
260:92-260:109
    Type -> Type
260:92-260:119
    Type | Type
260:108-260:109
    _f
260:111-260:116
    [Type] -> Type
260:111-260:118
    Type
260:117-260:118
    [Type]
262:1-262:6
    forall (a :: PrimitiveType) (b :: [Type])
      . String -> HList b -> PrimitiveStream a (HList b)
262:56-262:62
    Type
262:56-262:104
    Type | Type
262:66-262:71
    [Type] -> Type
262:66-262:73
    Type
262:66-262:104
    Type
262:72-262:73
    _c
262:77-262:92
    PrimitiveType -> Type -> Type
262:77-262:94
    Type -> Type
262:77-262:104
    Type | Type
262:93-262:94
    _e
262:96-262:101
    [Type] -> Type
262:96-262:103
    Type
262:102-262:103
    [Type]
264:1-264:10
    forall a . String -> a
264:14-264:20
    Type
264:14-264:25
    Type
264:24-264:25
    _c | Type
266:1-266:12
    forall (a :: PrimitiveType) (b :: [Type])
      . String
        -> forall (c :: [String])
          -> (len c ~ (len b :: Int)) => PrimitiveStream a (HList b)
266:31-266:37
    Type
266:31-266:123
    Type
266:32-266:36
    Type
266:41-266:47
    Type
266:41-266:123
    Type
266:51-266:123
    Type
266:65-266:73
    Type
266:66-266:72
    Type
266:78-266:81
    forall a . [a] -> Int
266:78-266:84
    Int
266:78-266:86
    Int -> Constraint
266:78-266:92
    Constraint
266:78-266:123
    Type
266:82-266:84
    [String]
266:85-266:86
    forall a . a -> a -> Constraint
266:87-266:90
    forall a . [a] -> Int
266:87-266:92
    Int
266:91-266:92
    [Type]
266:96-266:111
    PrimitiveType -> Type -> Type
266:96-266:113
    Type -> Type
266:96-266:123
    Type | Type
266:112-266:113
    _f
266:115-266:120
    [Type] -> Type
266:115-266:122
    Type
266:121-266:122
    [Type]
270:6-270:14
    Nat -> Type -> Type
270:21-270:27
    Nat -> Type -> Type
270:21-270:29
    Type -> Type
270:21-270:56
    Type
270:28-270:29
    _d
270:31-270:36
    Type -> Type
270:31-270:55
    Type
270:38-270:52
    Type -> Type
270:38-270:54
    Type
270:53-270:54
    _b
272:6-272:20
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
272:6-272:22
    Type | Type
272:6-272:39
    Type | Type
272:6-274:29
    Type | Type
272:21-272:22
    Type
272:25-272:39
    forall a . Vec 3 Float -> a -> SimpleFragment a | SimpleFragment
      _d | Type | Type | Type
273:7-273:22
    forall a . SimpleFragment a -> VecS Float 3
273:28-273:31
    Nat -> Type -> Type
273:28-273:33
    Type -> Type
273:28-273:39
    Type
273:32-273:33
    _b
273:34-273:39
    Type
274:7-274:21
    forall a . SimpleFragment a -> a
274:28-274:29
    Type
277:6-277:20
    Nat -> Type -> Type
277:27-277:41
    Type
277:28-277:36
    Nat -> Type -> Type
277:28-277:38
    Type -> Type
277:28-277:40
    Type
277:37-277:38
    _d
277:39-277:40
    _b
279:1-279:15
    forall a (b :: Nat) . (a -> Float) -> Fragment b a -> Fragment b a
279:19-279:63
    Type | Type
279:20-279:21
    _d
279:25-279:30
    Type | Type
279:35-279:43
    Nat -> Type -> Type
279:35-279:45
    Type -> Type
279:35-279:47
    Type
279:35-279:63
    Type
279:44-279:45
    _c
279:46-279:47
    Type
279:51-279:59
    Nat -> Type -> Type
279:51-279:61
    Type -> Type
279:51-279:63
    Type | Type
279:60-279:61
    Nat
279:62-279:63
    Type
281:20-281:76
    Type | Type
281:21-281:22
    _d
281:26-281:31
    Type | Type
281:36-281:50
    Nat -> Type -> Type
281:36-281:52
    Type -> Type
281:36-281:54
    Type
281:36-281:76
    Type
281:51-281:52
    _c
281:53-281:54
    Type
281:58-281:72
    Nat -> Type -> Type
281:58-281:74
    Type -> Type
281:58-281:76
    Type | Type
281:73-281:74
    Nat
281:75-281:76
    Type
282:1-282:16
    forall a (b :: Nat)
      . (a -> Float)
        -> [Vector b (Maybe (SimpleFragment a))]
          -> [Vector b (Maybe (SimpleFragment a))]
282:21-282:24
    forall a b . (a -> b) -> [a] -> [b]
282:21-282:43
    [Vector _a (Maybe (SimpleFragment _d))]
      -> [Vector _a (Maybe (SimpleFragment _d))]
282:26-282:40
    forall a (b :: Nat) . (a -> Float) -> Fragment b a -> Fragment b a
282:26-282:42
    Fragment _a _f -> Fragment _a _f
282:41-282:42
    _g -> Float
284:1-284:15
    forall a (b :: Nat) . (a -> Bool) -> Fragment b a -> Fragment b a
284:19-284:62
    Type | Type
284:20-284:21
    _d
284:25-284:29
    Type | Type
284:34-284:42
    Nat -> Type -> Type
284:34-284:44
    Type -> Type
284:34-284:46
    Type
284:34-284:62
    Type
284:43-284:44
    _c
284:45-284:46
    Type
284:50-284:58
    Nat -> Type -> Type
284:50-284:60
    Type -> Type
284:50-284:62
    Type | Type
284:59-284:60
    Nat
284:61-284:62
    Type
286:20-286:75
    Type | Type
286:21-286:22
    _d
286:26-286:30
    Type | Type
286:35-286:49
    Nat -> Type -> Type
286:35-286:51
    Type -> Type
286:35-286:53
    Type
286:35-286:75
    Type
286:50-286:51
    _c
286:52-286:53
    Type
286:57-286:71
    Nat -> Type -> Type
286:57-286:73
    Type -> Type
286:57-286:75
    Type | Type
286:72-286:73
    Nat
286:74-286:75
    Type
287:1-287:16
    forall a (b :: Nat)
      . (a -> Bool)
        -> [Vector b (Maybe (SimpleFragment a))]
          -> [Vector b (Maybe (SimpleFragment a))]
287:21-287:24
    forall a b . (a -> b) -> [a] -> [b]
287:21-287:43
    [Vector _a (Maybe (SimpleFragment _d))]
      -> [Vector _a (Maybe (SimpleFragment _d))]
287:26-287:40
    forall a (b :: Nat) . (a -> Bool) -> Fragment b a -> Fragment b a
287:26-287:42
    Fragment _a _f -> Fragment _a _f
287:41-287:42
    _g -> Bool
289:1-289:12
    forall a b (c :: Nat) . (a -> b) -> Fragment c a -> Fragment c b
289:16-289:56
    Type | Type | Type
289:17-289:18
    _f
289:22-289:23
    _e | Type
289:28-289:36
    Nat -> Type -> Type
289:28-289:38
    Type -> Type
289:28-289:40
    Type
289:28-289:56
    Type
289:37-289:38
    _c
289:39-289:40
    Type
289:44-289:52
    Nat -> Type -> Type
289:44-289:54
    Type -> Type
289:44-289:56
    Type | Type
289:53-289:54
    Nat
289:55-289:56
    Type
291:17-291:69
    Type | Type | Type
291:18-291:19
    _f
291:23-291:24
    _e | Type
291:29-291:43
    Nat -> Type -> Type
291:29-291:45
    Type -> Type
291:29-291:47
    Type
291:29-291:69
    Type
291:44-291:45
    _c
291:46-291:47
    Type
291:51-291:65
    Nat -> Type -> Type
291:51-291:67
    Type -> Type
291:51-291:69
    Type | Type
291:66-291:67
    Nat
291:68-291:69
    Type
292:1-292:13
    forall a b (c :: Nat)
      . (a -> b)
        -> [Vector c (Maybe (SimpleFragment a))]
          -> [Vector c (Maybe (SimpleFragment b))]
292:18-292:21
    forall a b . (a -> b) -> [a] -> [b]
292:18-292:37
    [Vector _a (Maybe (SimpleFragment _e))]
      -> [Vector _a (Maybe (SimpleFragment _d))]
292:23-292:34
    forall a b (c :: Nat) . (a -> b) -> Fragment c a -> Fragment c b
292:23-292:36
    Fragment _a _g -> Fragment _a _f
292:35-292:36
    _i -> _h
296:6-296:15
    Type | Type | Type | Type | Type | Type | Type | Type
296:6-299:14
    Type | Type | Type
297:7-297:12
    Type -> ImageKind | ImageKind | Type | Type
297:13-297:17
    Type
298:7-298:12
    ImageKind
299:7-299:14
    ImageKind
301:14-301:23
    Type
301:27-301:31
    Type | Type
302:1-302:10
    ImageKind -> Type
302:23-302:24
    Type
302:23-303:25
    Type -> ImageKind -> Type
302:23-304:25
    ImageKind -> Type | Type
303:19-303:25
    Type
304:21-304:25
    Type
306:6-306:11
    Nat -> ImageKind -> Type | Nat -> ImageKind -> Type | Nat
      -> ImageKind -> Type | Type | Type
306:6-306:38
    Type
306:18-306:21
    Type | Type
306:29-306:38
    Type | Type | Type
308:1-308:11
    forall (a :: Nat) (b :: Nat) c d
      . (Num c, d ~ VecScalar b c) => d -> Image a ('Color d)
308:45-309:55
    Type | Type | Type | Type
308:46-308:49
    Type -> Constraint
308:46-308:51
    Constraint
308:50-308:51
    _d
308:53-308:58
    _d
308:53-308:60
    _c -> Constraint
308:53-308:74
    Constraint
308:53-309:55
    Type
308:59-308:60
    forall a . a -> a -> Constraint
308:61-308:70
    Nat -> Type -> Type
308:61-308:72
    Type -> Type
308:61-308:74
    Type
308:71-308:72
    _f
308:73-308:74
    Type
309:24-309:29
    Type
309:24-309:55
    Type
309:34-309:39
    Nat -> ImageKind -> Type
309:34-309:41
    ImageKind -> Type
309:34-309:55
    Type | Type
309:40-309:41
    _h
309:43-309:48
    Type -> ImageKind
309:43-309:54
    ImageKind
309:49-309:54
    Type
310:1-310:11
    forall (a :: Nat) . Float -> Image a 'Depth
310:35-310:40
    Type
310:35-310:58
    Type
310:45-310:50
    Nat -> ImageKind -> Type
310:45-310:52
    ImageKind -> Type
310:45-310:58
    Type | Type
310:51-310:52
    _c
310:53-310:58
    ImageKind
311:1-311:13
    forall (a :: Nat) . Int -> Image a 'Stencil
311:35-311:38
    Type
311:35-311:60
    Type
311:45-311:50
    Nat -> ImageKind -> Type
311:45-311:52
    ImageKind -> Type
311:45-311:60
    Type | Type
311:51-311:52
    _c
311:53-311:60
    ImageKind
313:1-313:16
    Float -> Image 1 'Depth
313:19-313:29
    forall (a :: Nat) . Float -> Image a 'Depth
313:19-313:32
    Float -> Image 1 'Depth
313:31-313:32
    _b
314:1-314:16
    forall (a :: Nat) b c . (Num b, c ~ VecScalar a b) => c -> Image 1 ('Color c)
314:19-314:29
    forall (a :: Nat) (b :: Nat) c d
      . (Num c, d ~ VecScalar b c) => d -> Image a ('Color d)
314:19-314:32
    forall (a :: Nat) b c . (Num b, c ~ VecScalar a b) => c -> Image 1 ('Color c)
314:31-314:32
    _b
321:6-321:11
    Type | Type | Type | Type | Type | Type | Type | Type
321:6-321:31
    Type | Type | Type | Type
321:14-321:16
    Swizz
321:19-321:21
    Swizz
321:24-321:26
    Swizz
321:29-321:31
    Swizz
339:16-339:48
    Type
339:27-339:30
    Nat -> Type -> Type
339:27-339:32
    Type -> Type
339:27-339:34
    Type
339:27-339:48
    Type
339:31-339:32
    _b
339:33-339:34
    _c
339:38-339:43
    Type
339:38-339:48
    Type
339:47-339:48
    Type | Type
340:1-340:12
    forall a (b :: Nat) . Vec b a -> Swizz -> a
340:27-340:28
    _e
340:27-341:28
    _d -> _d -> Swizz -> _d | _c
340:27-344:30
    (forall (a :: _a) (b :: _a) (c :: _a) -> _a -> _a)
      -> forall (d :: Nat) . VecS _a d -> _a
340:27-348:32
    forall (a :: Nat) . VecS _a a -> _a | _d
341:27-341:28
    _d
342:29-342:30
    _e
342:29-343:30
    _d -> _d -> Swizz -> _d
342:29-344:30
    _d -> Swizz -> _d | _d
343:29-343:30
    _d
344:29-344:30
    _d
345:31-345:32
    _f
345:31-346:32
    _e -> _e -> Swizz -> _e
345:31-347:32
    _e -> Swizz -> _e
345:31-348:32
    Swizz -> _e | _e
346:31-346:32
    _e
347:31-347:32
    _e
348:31-348:32
    _e
351:28-351:31
    Nat -> Type -> Type
351:28-351:33
    Type -> Type
351:28-351:35
    Type
351:28-351:43
    Type | Type
351:32-351:33
    _b
351:34-351:35
    _c
351:39-351:43
    Type | Type
352:1-352:11
    forall a (b :: Nat) . Vec b a -> Bool
352:23-352:27
    Bool
352:23-353:29
    (forall (a :: _a) (b :: _a) (c :: _a) -> _a -> Bool)
      -> forall (d :: Nat) . VecS _a d -> Bool
352:23-354:31
    forall (a :: Nat) . VecS _a a -> Bool | Bool
353:25-353:29
    Bool
354:27-354:31
    Bool
356:16-356:71
    Type
356:27-356:71
    Type
356:38-356:41
    Nat -> Type -> Type
356:38-356:43
    Type -> Type
356:38-356:45
    Type
356:38-356:71
    Type
356:42-356:43
    _d
356:44-356:45
    _e
356:49-356:52
    Nat -> Type -> Type
356:49-356:54
    Type -> Type
356:49-356:60
    Type
356:49-356:71
    Type
356:53-356:54
    _c
356:55-356:60
    Type
356:64-356:67
    Nat -> Type -> Type
356:64-356:69
    Type -> Type
356:64-356:71
    Type | Type
356:68-356:69
    Nat
356:70-356:71
    Type
357:1-357:12
    forall a (b :: Nat) (c :: Nat) . Vec b a -> Vec c Swizz -> VecS a c
357:19-357:29
    forall a (b :: Nat) . Vec b a -> Bool
357:19-357:31
    Bool
357:19-357:58
    VecS _e _c
357:30-357:31
    Vec _f _g
357:34-357:40
    forall a b (c :: Nat) . (a -> b) -> VecS a c -> VecS b c
357:34-357:56
    VecS Swizz _a -> VecS _g _a
357:34-357:58
    VecS _e _c
357:42-357:53
    forall a (b :: Nat) . Vec b a -> Swizz -> a
357:42-357:55
    Swizz -> _i
357:54-357:55
    Vec _j _k
357:57-357:58
    Vec _d Swizz
361:6-361:20
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
361:6-376:23
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
362:7-362:13
    BlendingFactor
363:7-363:12
    BlendingFactor
364:7-364:15
    BlendingFactor
365:7-365:23
    BlendingFactor
366:7-366:15
    BlendingFactor
367:7-367:23
    BlendingFactor
368:7-368:15
    BlendingFactor
369:7-369:23
    BlendingFactor
370:7-370:15
    BlendingFactor
371:7-371:23
    BlendingFactor
372:7-372:20
    BlendingFactor
373:7-373:28
    BlendingFactor
374:7-374:20
    BlendingFactor
375:7-375:28
    BlendingFactor
376:7-376:23
    BlendingFactor
378:6-378:19
    Type | Type | Type | Type | Type | Type | Type | Type | Type
378:6-383:10
    Type | Type | Type | Type | Type
379:7-379:14
    BlendEquation
380:7-380:19
    BlendEquation
381:7-381:26
    BlendEquation
382:7-382:10
    BlendEquation
383:7-383:10
    BlendEquation
385:6-385:20
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
385:6-401:10
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
386:7-386:12
    LogicOperation
387:7-387:10
    LogicOperation
388:7-388:17
    LogicOperation
389:7-389:11
    LogicOperation
390:7-390:18
    LogicOperation
391:7-391:11
    LogicOperation
392:7-392:10
    LogicOperation
393:7-393:9
    LogicOperation
394:7-394:10
    LogicOperation
395:7-395:12
    LogicOperation
396:7-396:13
    LogicOperation
397:7-397:16
    LogicOperation
398:7-398:19
    LogicOperation
399:7-399:17
    LogicOperation
400:7-400:11
    LogicOperation
401:7-401:10
    LogicOperation
403:6-403:22
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
403:6-411:15
    Type | Type | Type | Type | Type | Type | Type | Type
404:7-404:13
    StencilOperation
405:7-405:13
    StencilOperation
406:7-406:16
    StencilOperation
407:7-407:13
    StencilOperation
408:7-408:17
    StencilOperation
409:7-409:13
    StencilOperation
410:7-410:17
    StencilOperation
411:7-411:15
    StencilOperation
413:6-413:24
    Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type | Type
413:6-421:13
    Type | Type | Type | Type | Type | Type | Type | Type
414:7-414:12
    ComparisonFunction
415:7-415:11
    ComparisonFunction
416:7-416:12
    ComparisonFunction
417:7-417:13
    ComparisonFunction
418:7-418:14
    ComparisonFunction
419:7-419:15
    ComparisonFunction
420:7-420:13
    ComparisonFunction
421:7-421:13
    ComparisonFunction
423:6-423:21
    Type | Type | Type | Type | Type | Type
423:6-425:18
    Type | Type
424:7-424:17
    ProvokingVertex
425:7-425:18
    ProvokingVertex
427:6-427:14
    Type | Type | Type | Type | Type | Type | Type
427:6-430:15
    Type | Type | Type
428:7-428:16
    CullMode
429:7-429:15
    CullMode
430:7-430:15
    CullMode
432:6-432:15
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
432:6-432:17
    Type | Type | Type | Type
432:6-433:22
    Type
432:6-434:23
    Type | Type | Type
432:6-434:36
    Type
432:16-432:17
    Type | Type
433:7-433:16
    forall a . Float -> PointSize a | PointSize _c | Type | Type
433:17-433:22
    Type
434:7-434:23
    forall a . (a -> Float) -> PointSize a | PointSize _d | Type | Type
434:25-434:26
    Type
434:30-434:35
    Type | Type
436:6-436:17
    Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type -> Type | Type
      -> Type | Type
436:6-436:19
    Type | Type | Type | Type | Type | Type
436:6-438:33
    Type
436:6-439:18
    Type | Type | Type | Type
436:6-439:24
    Type
436:18-436:19
    Type | Type | Type
437:7-437:18
    forall a . PolygonMode a | PolygonMode _b
438:7-438:19
    forall a . PointSize a -> PolygonMode a | PolygonMode _d | Type | Type
438:21-438:30
    Type -> Type
438:21-438:32
    Type
438:31-438:32
    Type
439:7-439:18
    forall a . Float -> PolygonMode a | PolygonMode _e | Type | Type
439:19-439:24
    Type
441:6-441:19
    Type | Type | Type | Type | Type | Type | Type
441:6-443:13
    Type | Type
441:6-443:25
    Type
442:7-442:15
    PolygonOffset
443:7-443:13
    Float -> Float -> PolygonOffset | PolygonOffset | Type | Type | Type
443:14-443:19
    Type
443:20-443:25
    Type
445:6-445:28
    Type | Type | Type | Type | Type | Type
445:6-447:16
    Type | Type
446:7-446:16
    PointSpriteCoordOrigin
447:7-447:16
    PointSpriteCoordOrigin
450:1-450:12
    () -> Vec 2 Float -> Vec 4 Float
450:16-450:18
    Type
450:22-450:25
    Nat -> Type -> Type
450:22-450:27
    Type -> Type
450:22-450:33
    Type
450:22-450:48
    Type
450:26-450:27
    _b
450:28-450:33
    Type
450:37-450:40
    Nat -> Type -> Type
450:37-450:42
    Type -> Type
450:37-450:48
    Type | Type
450:41-450:42
    _b
450:43-450:48
    Type
453:1-453:8
    forall a . String -> a
453:14-453:20
    Type
453:14-453:25
    Type
453:24-453:25
    _c | Type
455:6-455:19
    Type -> PrimitiveType -> Type | Type -> PrimitiveType -> Type | Type | Type
      -> PrimitiveType -> Type | Type | Type
455:6-458:111
    Type | Type | Type | Type
455:25-455:38
    Type
455:25-455:46
    Type
455:42-455:46
    Type | Type
456:3-456:14
    forall a
      . CullMode
        -> PolygonMode a
          -> PolygonOffset -> ProvokingVertex -> RasterContext a 'Triangle | RasterContext
      _f
      'Triangle
456:3-456:115
    Type | Type | Type | Type | Type
456:26-456:34
    Type
456:26-456:115
    Type
456:38-456:49
    Type -> Type
456:38-456:51
    Type
456:38-456:115
    Type
456:50-456:51
    Type
456:55-456:68
    Type
456:55-456:115
    Type
456:72-456:87
    Type
456:72-456:115
    Type
456:91-456:104
    Type -> PrimitiveType -> Type
456:91-456:106
    PrimitiveType -> Type
456:91-456:115
    Type | Type
456:105-456:106
    Type
456:107-456:115
    PrimitiveType | PrimitiveType
457:3-457:11
    forall a
      . PointSize a
        -> Float -> PointSpriteCoordOrigin -> RasterContext a 'Point | RasterContext
      _f
      'Point
457:3-457:112
    Type | Type | Type | Type
457:26-457:35
    Type -> Type
457:26-457:37
    Type
457:26-457:112
    Type
457:36-457:37
    Type
457:41-457:46
    Type
457:41-457:112
    Type
457:50-457:72
    Type
457:50-457:112
    Type
457:91-457:104
    Type -> PrimitiveType -> Type
457:91-457:106
    PrimitiveType -> Type
457:91-457:112
    Type | Type
457:105-457:106
    Type
457:107-457:112
    PrimitiveType | PrimitiveType
458:3-458:10
    forall a . Float -> ProvokingVertex -> RasterContext a 'Line | RasterContext
      _f
      'Line
458:3-458:111
    Type | Type | Type
458:26-458:31
    Type
458:26-458:111
    Type
458:35-458:50
    Type
458:35-458:111
    Type
458:91-458:104
    Type -> PrimitiveType -> Type
458:91-458:106
    PrimitiveType -> Type
458:91-458:111
    Type | Type
458:105-458:106
    Type
458:107-458:111
    PrimitiveType | PrimitiveType
460:6-460:14
    Type -> Type | Type -> Type | Type | Type -> Type | Type | Type
460:6-465:74
    Type | Type | Type
460:18-460:22
    Type
460:26-460:30
    Type | Type
461:3-461:13
    forall a . Blending a | Blending _a
461:3-461:70
    Type | Type
461:60-461:68
    Type -> Type
461:60-461:70
    Type | Type
461:69-461:70
    _b | Type
462:3-462:15
    forall a . Integral a => LogicOperation -> Blending a | Blending _c
462:3-462:70
    Type | Type | Type | Type
462:26-462:70
    Type
462:27-462:35
    Type -> Constraint
462:27-462:37
    Constraint
462:36-462:37
    _b
462:42-462:56
    Type
462:42-462:70
    Type
462:60-462:68
    Type -> Type
462:60-462:70
    Type | Type
462:69-462:70
    Type | Type
463:3-463:8
    (BlendEquation, BlendEquation)
      -> ((BlendingFactor, BlendingFactor), (BlendingFactor, BlendingFactor))
        -> Vec 4 Float -> Blending Float | Blending Float
463:3-465:74
    Type | Type | Type | Type
463:26-463:56
    Type
463:27-463:40
    Type
463:27-463:55
    [Type]
463:42-463:55
    Type | [Type]
464:29-464:97
    Type
464:29-465:74
    Type
464:30-464:62
    Type
464:30-464:96
    [Type]
464:31-464:45
    Type
464:31-464:61
    [Type]
464:47-464:61
    Type | [Type]
464:64-464:96
    Type | [Type]
464:65-464:79
    Type
464:65-464:95
    [Type]
464:81-464:95
    Type | [Type]
465:29-465:32
    Nat -> Type -> Type
465:29-465:34
    Type -> Type
465:29-465:40
    Type
465:29-465:74
    Type
465:33-465:34
    _b
465:35-465:40
    Type
465:60-465:68
    Type -> Type
465:60-465:74
    Type | Type
465:69-465:74
    Type | Type
467:6-467:18
    Type | Type | Type | Type
468:6-468:16
    Type | Type | Type | Type
470:6-470:23
    ImageKind -> Type | ImageKind -> Type | Type | ImageKind -> Type | Type | Type
470:6-473:96
    Type | Type | Type
470:27-470:36
    Type
470:40-470:44
    Type | Type
471:3-471:10
    forall a (b :: Nat)
      . Num a
        => Blending a
          -> VecScalar b Bool
            -> FragmentOperation ('Color (VecScalar b a)) | FragmentOperation
      ('Color (VecScalar _d _e))
471:3-471:112
    Type | Type | Type | Type | Type | Type
471:26-471:29
    Type -> Constraint
471:26-471:31
    Constraint
471:26-471:112
    Type | Type
471:30-471:31
    _d
471:35-471:43
    Type -> Type
471:35-471:45
    Type
471:35-471:112
    Type
471:44-471:45
    Type
471:49-471:58
    Nat -> Type -> Type
471:49-471:60
    Type -> Type
471:49-471:65
    Type
471:49-471:112
    Type
471:59-471:60
    _d
471:61-471:65
    Type
471:71-471:88
    ImageKind -> Type
471:71-471:112
    Type | Type
471:90-471:95
    Type -> ImageKind | Type -> ImageKind
471:90-471:111
    ImageKind | ImageKind
471:97-471:106
    Nat -> Type -> Type | Nat -> Type -> Type
471:97-471:108
    Type -> Type | Type -> Type
471:97-471:110
    Type | Type
471:107-471:108
    Nat | Nat
471:109-471:110
    Type | Type
472:3-472:10
    ComparisonFunction -> Bool -> FragmentOperation 'Depth | FragmentOperation
      'Depth
472:3-472:94
    Type | Type | Type
472:26-472:44
    Type
472:48-472:52
    Type
472:48-472:94
    Type
472:71-472:88
    ImageKind -> Type
472:71-472:94
    Type | Type
472:89-472:94
    ImageKind | ImageKind
473:3-473:12
    StencilTests
      -> StencilOps -> StencilOps -> FragmentOperation 'Stencil | FragmentOperation
      'Stencil
473:3-473:96
    Type | Type | Type | Type
473:26-473:38
    Type
473:42-473:52
    Type
473:42-473:96
    Type
473:56-473:66
    Type
473:56-473:96
    Type
473:71-473:88
    ImageKind -> Type
473:71-473:96
    Type | Type
473:89-473:96
    ImageKind | ImageKind
475:6-475:18
    Type -> Type | Type -> Type | Type -> Type | Type
475:6-478:7
    Type | Type | Type | Type
476:3-476:9
    forall a . Floating a => Interpolated a | Interpolated _c | Type | Type
476:11-476:24
    forall a . Floating a => Interpolated a | Interpolated _d | Type | Type
477:26-477:56
    Type | Type
477:27-477:35
    Type -> Constraint | Type -> Constraint
477:27-477:37
    Constraint | Constraint
477:36-477:37
    Type | Type
477:42-477:54
    Type -> Type | Type -> Type
477:42-477:56
    Type | Type | Type | Type
477:55-477:56
    Type | Type
478:3-478:7
    forall a . Interpolated a | Interpolated _d
478:42-478:54
    Type -> Type
478:42-478:56
    Type | Type
478:55-478:56
    Type
480:1-480:19
    forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (d :: PrimitiveType)
      . (map Interpolated a ~ (b :: [Type]), c ~ (Vec 4 Float : a :: [Type]))
        => HList b
          -> RasterContext (HList c) d
            -> Primitive (HList c) d -> FragmentStream 1 (HList a)
481:8-486:34
    Type | Type | Type | Type
481:10-481:13
    forall a b . (a -> b) -> [a] -> [b]
481:10-481:26
    [Type] -> [Type]
481:10-481:28
    [Type]
481:10-481:30
    [Type] -> Constraint
481:10-481:44
    Constraint
481:14-481:26
    Type -> Type
481:27-481:28
    _h
481:29-481:30
    forall a . a -> a -> Constraint
481:31-481:44
    _f
482:10-482:11
    _f
482:10-482:13
    _e -> Constraint
482:10-482:28
    Constraint
482:10-486:34
    Type
482:12-482:13
    forall a . a -> a -> Constraint
482:14-482:17
    Nat -> Type -> Type
482:14-482:19
    Type -> Type
482:14-482:25
    Type
482:14-482:26
    [Type] -> [Type]
482:14-482:28
    [Type]
482:18-482:19
    _b
482:20-482:25
    Type
482:25-482:26
    forall a . a -> [a] -> [a]
482:27-482:28
    [Type]
483:8-483:13
    [Type] -> Type
483:8-483:27
    Type
483:8-486:34
    Type
483:14-483:27
    [Type]
484:8-484:21
    Type -> PrimitiveType -> Type
484:8-484:31
    PrimitiveType -> Type
484:8-484:33
    Type
484:8-486:34
    Type
484:23-484:28
    [Type] -> Type
484:23-484:30
    Type
484:29-484:30
    [Type]
484:32-484:33
    _e
485:8-485:17
    Type -> PrimitiveType -> Type
485:8-485:27
    PrimitiveType -> Type
485:8-485:29
    Type
485:8-486:34
    Type
485:19-485:24
    [Type] -> Type
485:19-485:26
    Type
485:25-485:26
    [Type]
485:28-485:29
    PrimitiveType
486:8-486:22
    Nat -> Type -> Type
486:8-486:24
    Type -> Type
486:8-486:34
    Type | Type
486:23-486:24
    _b
486:26-486:31
    [Type] -> Type
486:26-486:33
    Type
486:32-486:33
    [Type]
488:1-488:20
    forall (a :: [Type]) (b :: PrimitiveType)
      . RasterContext (HList (Vec 4 Float : a)) b
        -> HList (map Interpolated a)
          -> [Primitive (HList (Vec 4 Float : a)) b]
            -> [Vector 1 (Maybe (SimpleFragment (HList a)))]
488:32-488:38
    forall a . [[a]] -> [a]
488:32-488:74
    [Vector 1 (Maybe (SimpleFragment (HList _b)))]
488:40-488:43
    forall a b . (a -> b) -> [a] -> [b]
488:40-488:71
    [Primitive (HList (Vec 4 Float : _b)) _a] -> [[Fragment 1 (HList _b)]]
488:40-488:73
    [[Fragment 1 (HList _b)]]
488:45-488:63
    forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (d :: PrimitiveType)
      . (map Interpolated a ~ (b :: [Type]), c ~ (Vec 4 Float : a :: [Type]))
        => HList b
          -> RasterContext (HList c) d
            -> Primitive (HList c) d -> FragmentStream 1 (HList a)
488:45-488:66
    RasterContext (HList (Vec 4 Float : _b)) _a
      -> Primitive (HList (Vec 4 Float : _b)) _a -> FragmentStream 1 (HList _b)
488:45-488:70
    Primitive (HList (Vec 4 Float : _b)) _a -> FragmentStream 1 (HList _b)
488:64-488:66
    _i
488:67-488:70
    _h
488:72-488:73
    _d
490:26-490:29
    Type | Type
490:36-490:43
    Type -> Nat
490:58-490:59
    Nat
492:12-492:15
    Type
492:12-492:29
    Type
492:13-492:14
    _b
492:19-492:29
    Type | Type
493:1-493:8
    forall a . [a] -> Constraint
493:14-493:20
    Constraint
493:14-495:50
    [_a] -> Constraint | Constraint
494:15-494:21
    Constraint
494:15-495:50
    [_c] -> Constraint | Constraint
495:22-495:25
    Constraint -> Constraint -> Constraint
495:22-495:33
    Constraint -> Constraint
495:22-495:50
    Constraint
495:27-495:28
    _g
495:27-495:30
    _f -> Constraint
495:27-495:32
    Constraint
495:29-495:30
    forall a . a -> a -> Constraint
495:31-495:32
    _c
495:35-495:42
    forall a . [a] -> Constraint
495:35-495:49
    Constraint
495:44-495:45
    _g
495:44-495:46
    [_f] -> [_f]
495:44-495:48
    [_e]
495:45-495:46
    forall a . a -> [a] -> [a]
495:46-495:48
    [_e]
497:1-497:16
    [Type] -> Constraint
497:21-497:28
    forall a . [a] -> Constraint
497:21-497:45
    Constraint
497:30-497:33
    forall a b . (a -> b) -> [a] -> [b]
497:30-497:42
    [Type] -> [Nat]
497:30-497:44
    [Nat]
497:34-497:42
    Type -> Nat
497:43-497:44
    _b
509:6-509:17
    Nat -> [ImageKind] -> Type | Nat -> [ImageKind] -> Type | Nat
      -> [ImageKind] -> Type | Type | Type
509:6-509:46
    Type
509:24-509:27
    Type | Type
509:35-509:46
    Type | Type | Type
509:36-509:45
    Type | Type
511:15-511:26
    Type
511:16-511:25
    Type
511:30-511:36
    Type | Type
511:31-511:35
    Type
512:1-512:11
    [ImageKind] -> [Type]
512:25-512:28
    forall a b . (a -> b) -> [a] -> [b]
512:25-512:38
    [ImageKind] -> [Type]
512:25-512:40
    [Type]
512:25-513:31
    [Type] -> ImageKind -> [Type] | [Type] | [Type]
512:29-512:38
    ImageKind -> Type
512:39-512:40
    [_c]
513:16-513:19
    forall a b . (a -> b) -> [a] -> [b] | forall a b
      . (a -> b) -> [a] -> [b] | forall a b . (a -> b) -> [a] -> [b]
513:16-513:29
    [ImageKind] -> [Type] | [ImageKind] -> [Type] | [ImageKind] -> [Type]
513:16-513:31
    [Type] | [Type] | [Type]
513:20-513:29
    ImageKind -> Type | ImageKind -> Type | ImageKind -> Type
513:30-513:31
    [ImageKind] | [ImageKind] | [ImageKind]
515:40-515:49
    Type | Type
515:56-515:77
    Type -> ImageKind
515:102-515:103
    ImageKind
517:1-517:11
    forall (a :: [ImageKind]) (b :: Nat) (c :: [Type])
      . (a ~ (map FragmentOperationKind c :: [ImageKind]))
        => HList c
          -> FragmentStream b (HList (imageType' a)) -> FrameBuffer b a -> FrameBuffer b a
517:15-517:174
    Type
517:28-517:31
    Type
517:39-517:45
    Type
517:39-517:174
    Type
517:40-517:44
    Type
517:49-517:174
    Type
517:50-517:51
    _e
517:50-517:53
    _d -> Constraint
517:50-517:81
    Constraint
517:52-517:53
    forall a . a -> a -> Constraint
517:54-517:57
    forall a b . (a -> b) -> [a] -> [b]
517:54-517:79
    [Type] -> [ImageKind]
517:54-517:81
    [ImageKind]
517:58-517:79
    Type -> ImageKind
517:80-517:81
    [Type]
517:86-517:91
    [Type] -> Type
517:86-517:93
    Type
517:86-517:174
    Type
517:92-517:93
    [Type]
517:97-517:111
    Nat -> Type -> Type
517:97-517:113
    Type -> Type
517:97-517:136
    Type
517:97-517:174
    Type
517:112-517:113
    Nat
517:115-517:120
    [Type] -> Type
517:115-517:135
    Type
517:122-517:132
    [ImageKind] -> [Type]
517:122-517:134
    [Type]
517:133-517:134
    [ImageKind]
517:140-517:151
    Nat -> [ImageKind] -> Type
517:140-517:153
    [ImageKind] -> Type
517:140-517:155
    Type
517:140-517:174
    Type
517:152-517:153
    Nat
517:154-517:155
    [ImageKind]
517:159-517:170
    Nat -> [ImageKind] -> Type
517:159-517:172
    [ImageKind] -> Type
517:159-517:174
    Type | Type
517:171-517:172
    Nat
517:173-517:174
    [ImageKind]
519:1-519:15
    forall a b . a -> b -> (a, b)
519:24-519:32
    (_d, _b)
519:25-519:28
    _f
519:30-519:31
    _e | ((_b))
520:1-520:8
    forall (a :: Nat) (b :: [Type])
      . FrameBuffer a (map FragmentOperationKind b)
        -> (HList b, [Fragment a (HList (imageType' (map FragmentOperationKind b)))])
          -> FrameBuffer a (map FragmentOperationKind b)
520:25-520:35
    forall (a :: [ImageKind]) (b :: Nat) (c :: [Type])
      . (a ~ (map FragmentOperationKind c :: [ImageKind]))
        => HList c
          -> FragmentStream b (HList (imageType' a)) -> FrameBuffer b a -> FrameBuffer b a
520:25-520:39
    FragmentStream _b (HList (imageType' (map FragmentOperationKind _a)))
      -> FrameBuffer _b (map FragmentOperationKind _a)
        -> FrameBuffer _b (map FragmentOperationKind _a)
520:25-520:43
    FrameBuffer _b (map FragmentOperationKind _a)
      -> FrameBuffer _b (map FragmentOperationKind _a)
520:25-520:46
    FrameBuffer _b (map FragmentOperationKind _a) | FrameBuffer
      _b
      (map FragmentOperationKind _a) | FrameBuffer _b (map FragmentOperationKind _a)
520:36-520:39
    _m
520:40-520:43
    _h
520:44-520:46
    _n
524:31-524:40
    Type | Type
524:47-524:59
    Type -> ImageKind
524:74-524:75
    ImageKind
530:1-530:12
    forall (a :: [Type])
      . sameLayerCounts a
        => HList a -> FrameBuffer (ImageLC (head a)) (map GetImageKind a)
530:30-530:36
    Type
530:31-530:35
    Type
530:40-530:125
    Type
530:41-530:56
    [Type] -> Constraint
530:41-530:58
    Constraint
530:57-530:58
    [Type]
530:63-530:68
    [Type] -> Type
530:63-530:70
    Type
530:63-530:125
    Type
530:69-530:70
    [Type]
530:74-530:85
    Nat -> [ImageKind] -> Type
530:74-530:104
    [ImageKind] -> Type
530:74-530:125
    Type | Type
530:87-530:94
    Type -> Nat
530:87-530:103
    Nat
530:96-530:100
    forall a . [a] -> a
530:96-530:102
    Type
530:101-530:102
    [Type]
530:106-530:109
    forall a b . (a -> b) -> [a] -> [b]
530:106-530:122
    [Type] -> [ImageKind]
530:106-530:124
    [ImageKind]
530:110-530:122
    Type -> ImageKind
530:123-530:124
    [Type]
532:1-532:11
    forall (a :: [Type])
      . sameLayerCounts a
        => HList a -> FrameBuffer (ImageLC (head a)) (map GetImageKind a)
532:14-532:25
    forall (a :: [Type])
      . sameLayerCounts a
        => HList a -> FrameBuffer (ImageLC (head a)) (map GetImageKind a)
534:1-534:11
    forall (a :: Nat) (b :: [Type]) c
      . HList b
        -> (c -> HList (imageType' (map FragmentOperationKind b)))
          -> [Vector a (Maybe (SimpleFragment c))]
            -> FrameBuffer a (map FragmentOperationKind b)
              -> FrameBuffer a (map FragmentOperationKind b)
534:34-534:44
    forall (a :: [ImageKind]) (b :: Nat) (c :: [Type])
      . (a ~ (map FragmentOperationKind c :: [ImageKind]))
        => HList c
          -> FragmentStream b (HList (imageType' a)) -> FrameBuffer b a -> FrameBuffer b a
534:34-534:48
    FragmentStream _b (HList (imageType' (map FragmentOperationKind _a)))
      -> FrameBuffer _b (map FragmentOperationKind _a)
        -> FrameBuffer _b (map FragmentOperationKind _a)
534:34-534:76
    FrameBuffer _c (map FragmentOperationKind _b)
      -> FrameBuffer _c (map FragmentOperationKind _b)
534:34-534:79
    FrameBuffer _c (map FragmentOperationKind _b)
534:45-534:48
    _j
534:50-534:62
    forall a b (c :: Nat)
      . (a -> b)
        -> [Vector c (Maybe (SimpleFragment a))]
          -> [Vector c (Maybe (SimpleFragment b))]
534:50-534:70
    [Vector _a (Maybe (SimpleFragment _c))]
      -> [Vector _a (Maybe (SimpleFragment _b))]
534:50-534:75
    [Vector
      _c
      (Maybe (SimpleFragment (HList (imageType' (map FragmentOperationKind _b)))))]
534:63-534:70
    _k
534:71-534:75
    _g
534:77-534:79
    _e
537:1-537:9
    forall (a :: ImageKind) . FrameBuffer 1 ' [a] -> Image 1 a
537:24-537:35
    Nat -> [ImageKind] -> Type
537:24-537:37
    [ImageKind] -> Type
537:24-537:42
    Type
537:24-537:55
    Type
537:36-537:37
    _b
537:38-537:42
    [ImageKind]
537:40-537:41
    _c
537:46-537:51
    Nat -> ImageKind -> Type
537:46-537:53
    ImageKind -> Type
537:46-537:55
    Type | Type
537:52-537:53
    _b
537:54-537:55
    ImageKind
538:1-538:14
    FrameBuffer 1 ' ['Depth, 'Color (Vec 4 Float)] -> Image 1 ('Color (Vec 4 Float))
538:24-538:35
    Nat -> [ImageKind] -> Type
538:24-538:37
    [ImageKind] -> Type
538:24-538:70
    Type
538:36-538:37
    _b
538:38-538:70
    [ImageKind]
538:41-538:47
    ImageKind
538:49-538:55
    Type -> ImageKind
538:49-538:69
    ImageKind | [ImageKind]
538:57-538:60
    Nat -> Type -> Type
538:57-538:62
    Type -> Type
538:57-538:68
    Type
538:61-538:62
    _b
538:63-538:68
    Type
538:74-538:79
    Nat -> ImageKind -> Type
538:74-538:81
    ImageKind -> Type
538:74-538:103
    Type | Type
538:80-538:81
    _b
538:83-538:88
    Type -> ImageKind
538:83-538:102
    ImageKind
538:90-538:93
    Nat -> Type -> Type
538:90-538:95
    Type -> Type
538:90-538:101
    Type
538:94-538:95
    _b
538:96-538:101
    Type
540:6-540:12
    Type | Type | Type | Type
540:6-541:12
    Type
541:3-541:12
    forall (a :: Nat) (b :: [ImageKind])
      . FrameBuffer a b -> Output | Output | Type | Type | Type | Type
541:26-541:37
    Nat -> [ImageKind] -> Type
541:26-541:39
    [ImageKind] -> Type
541:26-541:41
    Type
541:26-541:51
    Type | Type
541:38-541:39
    _d
541:40-541:41
    _b
541:45-541:51
    Type | Type
543:1-543:12
    forall (a :: Nat) (b :: [ImageKind]) . FrameBuffer a b -> Output
543:15-543:24
    forall (a :: Nat) (b :: [ImageKind]) . FrameBuffer a b -> Output
549:6-549:13
    Type | Type | Type | Type
549:6-553:12
    Type | Type
550:3-550:16
    String -> Texture | Texture | Type | Type
550:20-550:26
    Type
551:20-551:27
    Type | Type
553:3-553:12
    Vec 2 Int
      -> Image 1 ('Color (Vec 4 Float)) -> Texture | Texture | Type | Type | Type
553:20-553:23
    Nat -> Type -> Type
553:20-553:25
    Type -> Type
553:20-553:29
    Type
553:24-553:25
    _b
553:26-553:29
    Type
554:20-554:25
    Nat -> ImageKind -> Type
554:20-554:27
    ImageKind -> Type
554:20-554:49
    Type
554:20-555:27
    Type
554:26-554:27
    _b
554:29-554:34
    Type -> ImageKind
554:29-554:48
    ImageKind
554:36-554:39
    Nat -> Type -> Type
554:36-554:41
    Type -> Type
554:36-554:47
    Type
554:40-554:41
    _b
554:42-554:47
    Type
555:20-555:27
    Type | Type
557:6-557:12
    Type | Type | Type | Type | Type | Type
557:6-559:17
    Type | Type
558:5-558:16
    Filter
559:5-559:17
    Filter
561:6-561:14
    Type | Type | Type | Type | Type | Type | Type
561:6-564:16
    Type | Type | Type
562:5-562:11
    EdgeMode
563:5-563:19
    EdgeMode
564:5-564:16
    EdgeMode
566:6-566:13
    Type | Type | Type | Type | Type | Type
566:6-566:23
    Type
566:6-566:47
    Type | Type
566:16-566:23
    Filter -> EdgeMode -> Texture -> Sampler | Sampler | Type | Type | Type | Type
566:24-566:30
    Type
566:31-566:39
    Type
566:40-566:47
    Type
569:1-569:10
    Sampler -> Vec 2 Float -> Vec 4 Float
569:14-569:21
    Type
569:25-569:28
    Nat -> Type -> Type
569:25-569:30
    Type -> Type
569:25-569:36
    Type
569:25-569:51
    Type
569:29-569:30
    _b
569:31-569:36
    Type
569:40-569:43
    Nat -> Type -> Type
569:40-569:45
    Type -> Type
569:40-569:51
    Type | Type
569:44-569:45
    _b
569:46-569:51
    Type
573:1-573:20
    forall a . a -> a
573:25-573:26
    _b
------------ warnings
Uncovered pattern(s) at testdata/Builtins.lc:201:1:
head (x: _) = x
^^^^
Missing case(s):
    head []
Uncovered pattern(s) at testdata/Builtins.lc:340:1:
swizzscalar (V2 x y) Sx = x
swizzscalar (V2 x y) Sy = y
swizzscalar (V3 x y z) Sx = x
swizzscalar (V3 x y z) Sy = y
swizzscalar (V3 x y z) Sz = z
swizzscalar (V4 x y z w) Sx = x
swizzscalar (V4 x y z w) Sy = y
swizzscalar (V4 x y z w) Sz = z
swizzscalar (V4 x y z w) Sw = w
Missing case(s):
    swizzscalar (V2 _ _) Sz
    swizzscalar (V2 _ _) Sw
    swizzscalar (V3 _ _ _) Sw
Uncovered pattern(s) at testdata/Builtins.lc:357:1:
swizzvector v w | definedVec v = mapVec (swizzscalar v) w
^^^^^^^^^^^
Missing case(s):
    swizzvector _ _ | False <- definedVec _b