diff --git a/deptycheck.ipkg b/deptycheck.ipkg
index 0567ce555..e0828c75e 100644
--- a/deptycheck.ipkg
+++ b/deptycheck.ipkg
@@ -26,6 +26,7 @@ modules = Deriving.DepTyCheck.Gen
         , Deriving.DepTyCheck.Util.ArgsPerm
         , Deriving.DepTyCheck.Util.DeepConsApp
         , Deriving.DepTyCheck.Util.Primitives
+        , Deriving.DepTyCheck.Util.Specialisation
         , Test.DepTyCheck.Gen
         , Test.DepTyCheck.Gen.Coverage
         , Test.DepTyCheck.Gen.Emptiness
@@ -35,6 +36,8 @@ depends = ansi
         , best-alternative
         , dependent-vect
         , elab-util-extra
+        , hashable
+        , hashable-derive
         , i-hate-parens
         , if-unsolved-implicit
         , mtl-tuple-impls
diff --git a/elab-util-extra/src/Deriving/SpecialiseData.idr b/elab-util-extra/src/Deriving/SpecialiseData.idr
index f976db47f..439ce14d2 100644
--- a/elab-util-extra/src/Deriving/SpecialiseData.idr
+++ b/elab-util-extra/src/Deriving/SpecialiseData.idr
@@ -1,31 +1,34 @@
 module Deriving.SpecialiseData
 
 import Control.Monad.Either
-import Control.Monad.Error.Either
-import Control.Monad.Error.Interface
-import Control.Monad.Reader.Tuple
 import Control.Monad.Trans
-import Data.SnocList
 import Data.DPair
-import Data.List1
-import Data.Vect
-import Data.Vect.Quantifiers
+import Data.Either
+import Data.Fin.Set
 import Data.List
+import public Data.List.Map -- workaround for compiler bug
 import Data.List.Quantifiers
-import Data.Either
+import Data.List1
+import Data.Maybe
+import Data.SnocList
+import Data.SnocList.Quantifiers
 import Data.SortedMap
-import Data.SortedSet
 import Data.SortedMap.Dependent
-import Decidable.Equality
+import Data.SortedSet
+import Data.Vect
+import Data.Vect.Quantifiers
+import public Decidable.Decidable
+import public Decidable.Equality
 import Deriving.Show
 import public Language.Mk
 import Language.Reflection.Compat
 import Language.Reflection.Compat.Constr
-import Language.Reflection.Compat.TypeInfo
+import public Language.Reflection.Compat.TypeInfo -- workaround for compiler bug
 import Language.Reflection.Expr
+import Language.Reflection.Syntax
 import Language.Reflection.Logging
-import Language.Reflection.Unify
-import Language.Reflection.VarSubst
+import public Language.Reflection.Unify.Interface
+import public Language.Reflection.VarSubst -- workaround for compiler bug
 import Syntax.IHateParens
 
 %language ElabReflection
@@ -82,6 +85,8 @@ record SpecTask where
   resultName          : Name
   ||| Invocation of polymorphic type extracted from unification task
   fullInvocation      : TTImp
+  ||| Invocation of specialised type given default arguents
+  specInvocation      : TTImp
   ||| Polymorphic type's TypeInfo
   polyTy              : TypeInfo
   ||| Proof that all the constructors of the polymorphic type are named
@@ -96,6 +101,7 @@ Show SpecTask where
       , showArg t.currentNs
       , showArg t.resultName
       , showArg t.fullInvocation
+      , showArg t.specInvocation
       , showArg "<polyTy>"
       ]
 
@@ -107,18 +113,23 @@ UniResults = List UnificationVerdict
 --- HELPER FUNCTIONS ---
 ------------------------
 
+public export
+record SpecialisationParams where
+  constructor MkSpecParams
+  eraseConNames : Bool
+
+public export
+%defaulthint
+SpecialisationDefaults : SpecialisationParams
+SpecialisationDefaults = MkSpecParams
+  { eraseConNames = False
+  }
+
 public export
 interface NamespaceProvider (0 m : Type -> Type) where
   constructor MkNSProvider
   provideNS : m Namespace
 
-export %defaulthint
-CurrentNS : Elaboration m => NamespaceProvider m
-CurrentNS = MkNSProvider $ do
-    NS nsn _ <- inCurrentNS ""
-    | _ => fail "Internal error: inCurrentNS did not return NS"
-    pure nsn
-
 export
 Monad m => MonadTrans t => NamespaceProvider m => NamespaceProvider (t m) where
   provideNS = lift provideNS
@@ -127,15 +138,22 @@ export
 inNS : Monad m => Namespace -> NamespaceProvider m
 inNS ns = MkNSProvider $ pure ns
 
-||| Prepend namespace into which everything is generated to name
-inGenNS : SpecTask -> Name -> Name
-inGenNS task n = do
-  let MkNS tns = task.currentNs
+export
+%defaulthint
+NoNS : Monad m => NamespaceProvider m
+NoNS = inNS (MkNS [])
+
+inGenNSImpl : Namespace -> Name -> Name -> Name
+inGenNSImpl (MkNS strs) p n = do
   let newNS =
     case n of
-       (NS (MkNS subs) n) => subs
-       n => []
-  NS (MkNS $ newNS ++ show task.resultName :: tns) $ dropNS n
+        (NS (MkNS subs) n) => subs
+        n => []
+  NS (MkNS $ newNS ++ show p :: strs) $ dropNS n
+
+||| Prepend namespace into which everything is generated to name
+inGenNS : SpecTask -> Name -> Name
+inGenNS task = inGenNSImpl task.currentNs task.resultName
 
 ||| Given a sequence of arguments, return list of argument name-BindVar pairs
 argsToBindMap : Foldable f => f Arg -> List (Name, TTImp)
@@ -162,12 +180,6 @@ applyArgAliases (x :: xs) @{_ :: _} ys ins = do
 prependS : String -> Name -> Name
 prependS s n = UN $ Basic $ s ++ show n
 
-||| Given a list of arguments, generate a list of aliases for them
-transformArgNames' : (f : Name -> Name) -> (as : List Arg) -> (0 _ : All IsNamedArg as) => List (Name, Name)
-transformArgNames' _ [] = []
-transformArgNames' f (x :: xs) @{_ :: _} =
-  (argName x, f $ Expr.argName x) :: transformArgNames' f xs
-
 ||| Given a list of arguments, generate a list of aliased arguments
 ||| and a list of aliases
 transformArgNames :
@@ -176,28 +188,9 @@ transformArgNames :
   (0 _ : All IsNamedArg as) =>
   (Subset (List Arg) (All IsNamedArg), List (Name, Name))
 transformArgNames f as = do
-  let aliases = transformArgNames' f as
+  let aliases = pushIn as %search <&> \(x `Element` xN) => (argName x, f $ Expr.argName x @{xN})
   (applyArgAliases as aliases empty, aliases)
 
-||| Given a list of aliased argument pairs, generate a list of equality type
-||| for each pair
-mkEqualsTuple : List (Subset Arg IsNamedArg, Subset Arg IsNamedArg) -> TTImp
-mkEqualsTuple [] = `(MkUnit)
-mkEqualsTuple [(Element a1 _, Element a2 _)] =
-  `(~(var $ argName a1) ~=~ ~(var $ argName a2))
-mkEqualsTuple ((Element a1 _, Element a2 _) :: as) =
-  `(Pair (~(var $ argName a1) ~=~ ~(var $ argName a2)) ~(mkEqualsTuple as))
-
-||| Given a list of aliased argument pairs [(a, b), ...], generate a series of
-||| named applications: (... {a=a} {b=a})
-mkDoubleBinds : SnocList (Arg, Arg) -> TTImp -> TTImp
-mkDoubleBinds [<] t = t
-mkDoubleBinds (as :< (a1, a2)) t =
-  case (a1.name, a2.name) of
-    (Just a1n, Just a2n) =>
-      mkDoubleBinds as t .! (a1n, bindVar a1n) .! (a2n, bindVar a1n)
-    _ => mkDoubleBinds as t
-
 ||| Make an argument omega implicit if it is explicit
 hideExplicitArg : Arg -> Arg
 hideExplicitArg a = { piInfo := if a.piInfo == ExplicitArg then ImplicitArg else a.piInfo } a
@@ -214,11 +207,13 @@ makeTypeArgM0 a = { count := if a.type == `(Type) then M0 else a.count } a
 tupleOfN : Nat -> TTImp -> TTImp
 tupleOfN 0 _ = `(Unit)
 tupleOfN 1 t = t
-tupleOfN (S n) t = `(MkPair ~(t) ~(tupleOfN n t))
+tupleOfN (S n) t = `(MkPair ~t ~(tupleOfN n t))
 
-||| Map all unmapped variables from the list to their aliases
-mergeAliases : SortedMap Name TTImp -> List (Name, Name) -> SortedMap Name TTImp
-mergeAliases m = mergeWith (Prelude.curry fst) m . fromList . map (mapSnd var)
+||| Assemble a TTImp of a tuple from a list of `TTImp`s
+tupleOf : List TTImp -> TTImp
+tupleOf [] = `(())
+tupleOf [x] = x
+tupleOf (x :: xs) = `(MkPair ~x ~(tupleOf xs))
 
 ||| Proof that hideExplicitArg doesn't affect namedness of arguments
 hideExplicitArgPreservesNames :
@@ -248,29 +243,13 @@ hideExplicitArgs xs = hideExplicitArg <$> xs `Element` hideExplicitArgPreservesN
 makeArgsImplicit : (xs : List Arg) -> (0 _ : All IsNamedArg xs) => Subset (List Arg) (All IsNamedArg)
 makeArgsImplicit xs = makeImplicit <$> xs `Element` makeImplicitPreservesNames xs
 
-||| Create a binding application of aliased arguments
-||| binding everything to `(_)
-aliasedAppBind : SnocList (Name, Name) -> TTImp -> TTImp
-aliasedAppBind [<] t = t
-aliasedAppBind (xs :< (n, an)) t = aliasedAppBind xs t .! (an, `(_))
-
-
-||| Create a non-binding application of aliased arguments
-aliasedApp : SnocList (Name, Name) -> TTImp -> TTImp
-aliasedApp [<] t = t
-aliasedApp (xs :< (n, an)) t = aliasedApp xs t .! (n, var an)
-
 ---------------------
 --- TASK ANALYSIS ---
 ---------------------
 
 ||| Given a list of arguments and a sorted set of names,
 ||| assert that every argument's name is in that set
-checkArgsUse :
-  MonadError SpecialisationError m =>
-  List Arg ->
-  SortedSet Name ->
-  m ()
+checkArgsUse : MonadError SpecialisationError m => List Arg -> SortedSet Name -> m ()
 checkArgsUse [] _ = pure ()
 checkArgsUse (x :: xs) t = do
   let Just n = x.name
@@ -279,11 +258,36 @@ checkArgsUse (x :: xs) t = do
     then checkArgsUse xs t
     else throwError UnusedVarError
 
+||| Remove named and auto-implicit applications of holes
 cleanupHoleAutoImplicitsImpl : TTImp -> TTImp
 cleanupHoleAutoImplicitsImpl (IAutoApp _ x (Implicit _ _)) = x
 cleanupHoleAutoImplicitsImpl (INamedApp _ x _ (Implicit _ _)) = x
 cleanupHoleAutoImplicitsImpl x = x
 
+||| Generate an AnyApp for given Arg, with the argument value either
+||| retrieved from the map if present or generated with `fallback`
+(.appWith) :
+  (arg : Arg) ->
+  (0 _ : IsNamedArg arg) =>
+  (fallback : Name -> TTImp) ->
+  (argValues : SortedMap Name TTImp) ->
+  AnyApp
+(.appWith) arg@(MkArg _ _ (Just n) _) f argVals =
+  appArg arg $ fromMaybe (f n) $ lookup n argVals
+
+||| Generate a List AnyApp for given argument List,
+||| with arguments retrieved from the map if present or generated with `fallback`
+(.appsWith) :
+  (args: List Arg) ->
+  (0 _ : All IsNamedArg args) =>
+  (fallback : Name -> TTImp) ->
+  (argValues : SortedMap Name TTImp) ->
+  List AnyApp
+(.appsWith) [] _ _ = []
+(.appsWith) (x :: xs) @{_ :: _} f argVals =
+  x.appWith f argVals :: xs.appsWith f argVals
+
+
 ||| Get all the information needed for specialisation from task
 getTask :
   Monad m =>
@@ -305,7 +309,7 @@ getTask resultName resultKind resultContent = do
   let Yes tqArgsNamed = all isNamedArg tqArgs
   | _ => throwError UnnamedArgInLambdaError
   -- Create aliases for spec lambda's arguments and perform substitution
-  let (Element tqArgs tqArgsNamed, tqAlias) = transformArgNames (prependS "fv^") tqArgs
+  let (Element tqArgs tqArgsNamed, tqAlias) = transformArgNames (prependS "fv^\{resultName}^") tqArgs
   let tqRet = substituteVariables (fromList $ mapSnd var <$> tqAlias) tqRet
   let (ttArgs, _) = unPi resultKind
   -- Check for partial application in spec
@@ -324,6 +328,9 @@ getTask resultName resultKind resultContent = do
   -- Prove all its arguments/constructors/constructor arguments are named
   let Yes polyTyNamed = areAllTyArgsNamed polyTy
     | No _ => throwError $ UnnamedArgInPolyTyError polyTy.name
+  let specInvocation = reAppAny
+          (var (inGenNSImpl currentNs (snd $ unNS $ resultName) (snd $ unNS $ resultName))) $
+            ttArgs.appsWith @{ttArgsNamed} var empty
   pure $ MkSpecTask
     { tqArgs
     , tqRet
@@ -331,35 +338,13 @@ getTask resultName resultKind resultContent = do
     , ttArgs
     , ttArgsNamed
     , currentNs
-    , resultName
+    , resultName = snd $ unNS resultName
     , fullInvocation = tqRet --- TODO: intelligent full invocation
+    , specInvocation
     , polyTy
     , polyTyNamed
     }
 
-||| Generate an AnyApp for given Arg, with the argument value either
-||| retrieved from the map if present or generated with `fallback`
-(.appWith) :
-  (arg : Arg) ->
-  (0 _ : IsNamedArg arg) =>
-  (fallback : Name -> TTImp) ->
-  (argValues : SortedMap Name TTImp) ->
-  AnyApp
-(.appWith) arg@(MkArg _ _ (Just n) _) f argVals =
-  appArg arg $ fromMaybe (f n) $ lookup n argVals
-
-||| Generate a List AnyApp for given argument List,
-||| with arguments retrieved from the map if present or generated with `fallback`
-(.appsWith) :
-  (args: List Arg) ->
-  (0 _ : All IsNamedArg args) =>
-  (fallback : Name -> TTImp) ->
-  (argValues : SortedMap Name TTImp) ->
-  List AnyApp
-(.appsWith) [] _ _ = []
-(.appsWith) (x :: xs) @{_ :: _} f argVals =
-  x.appWith f argVals :: xs.appsWith f argVals
-
 namespace TypeInfoInvoke
   ||| Returns a full application of the given type constructor
   ||| with argument values sourced from `argValues`
@@ -387,11 +372,96 @@ namespace ConInvoke
     TTImp
   (.apply) con f vals = reAppAny (var con.name) $ con.args.appsWith f vals @{conArgsNamed}
 
-allL2V : (l : List t) -> (0 pr : All p l) => Subset (Vect (length l) t) (All p)
-allL2V [] = Element [] []
-allL2V (x :: xs) @{p :: ps} = do
-  let Element xs' ps' = allL2V xs @{ps}
-  Element (x :: xs') (p :: ps')
+namespace VectAll
+  ||| Proof that Vect.All works over Vect.snoc
+  export
+  0 snoc: All p prev -> p new -> All p (Data.Vect.snoc prev new)
+  snoc [] y = [y]
+  snoc (y :: ys) z = y :: snoc ys z
+
+  ||| List + List.All to Vect + Vect.All
+  export
+  fromListAll : (l : List t) -> (0 pr : All p l) => Subset (Vect (length l) t) (All p)
+  fromListAll [] = Element [] []
+  fromListAll (x :: xs) @{p :: ps} = do
+    let Element xs' ps' = fromListAll xs @{ps}
+    Element (x :: xs') (p :: ps')
+
+namespace ListAll
+  ||| Proof that List.All works over List.snoc
+  export
+  0 snoc : All p prev -> p new -> All p (Data.List.snoc prev new)
+  snoc [] y = [y]
+  snoc (y :: ys) z = y :: snoc ys z
+
+namespace SnocListAll
+  ||| SnocList + SnocList.All to List + List.All
+  export
+  toListAll : (sl : SnocList Arg) -> (0 _ : All p sl) -> Subset (List Arg) (All p)
+  toListAll [<] [<] = Element [] []
+  toListAll (sx :< x) (sy :< y) = do
+    let Element xs ys = toListAll sx sy
+    Element (snoc xs x) (snoc ys y)
+
+||| Internal state of recursion search algorithm
+record RecursionSearchState where
+  constructor MkRSS
+  ||| Accumulated transformation to cast from argument type to specialised type
+  mToPRenames : SortedMap Name TTImp
+  ||| Accumulated transformation to cast from specialised type to argument type
+  pToMRenames : SortedMap Name TTImp
+  ||| SnocList containing recursiveness of previous arguments
+  areArgsRecursive : SnocList Bool
+  ||| The pre-baked arguments to run unification with.
+  argsForUnifier : Subset (Vect (length areArgsRecursive) Arg) (All IsNamedArg)
+  ||| Accumulated arguments to be used in specialised constructor
+  argsOutput : Subset (SnocList Arg) (All IsNamedArg)
+
+||| Specialistaion-related constructor argument metadata
+record ArgMeta where
+  constructor MkAMeta
+  ||| The argument's type can be substituted by specialised type invocation
+  isRecursiveArg : Bool
+
+||| Specialisation-related constructor metadat
+record ConMeta where
+  constructor MkCMeta
+  ||| Metadata for each argument
+  argMeta : List ArgMeta
+  ||| Replacements to transform original argument's type to specialised type
+  mToPRenames : SortedMap Name TTImp
+  ||| Replacement to transform specialised type to original argument's type
+  pToMRenames : SortedMap Name TTImp
+
+hasRecursiveArgs : ConMeta -> Bool
+hasRecursiveArgs = any isRecursiveArg . argMeta
+
+countRecursiveArgs : ConMeta -> Nat
+countRecursiveArgs = count isRecursiveArg  . argMeta
+
+recursiveArgNames : Con -> ConMeta -> List Name
+recursiveArgNames con meta = do
+  let recursiveArgPairs = List.filter (isRecursiveArg . snd) $ zip con.args meta.argMeta
+  fromMaybe "" . name . fst <$> recursiveArgPairs
+
+||| Specialisation-related type metadata
+record TypeMeta where
+  constructor MkTyMeta
+  ||| Specialisation-related metadata for each constructor
+  conMeta : List ConMeta
+
+||| Generate a constructor binding where only recursive arguments are bound.
+||| Said arguments are also aliased via `alias` function.
+bindConRecArgsAliased : Con -> ConMeta -> (Name -> Name) -> TTImp
+bindConRecArgsAliased con meta alias =
+  reAppAny (var con.name) $ processArg <$> zip con.args meta.argMeta
+  where
+  maybeBind : Arg -> ArgMeta -> TTImp
+  maybeBind a am = if isRecursiveArg am then bindVar $ alias $ fromMaybe "" a.name else `(_)
+
+  processArg : (Arg, ArgMeta) -> AnyApp
+  processArg (a@(MkArg _ ExplicitArg _ _), am) = PosApp $ maybeBind a am
+  processArg (a, am) = NamedApp (fromMaybe "" a.name) $ maybeBind a am
 
 parameters (t : SpecTask)
   ---------------------------
@@ -412,16 +482,17 @@ parameters (t : SpecTask)
     (f : UnificationResult ->
          (pCon : Con) ->
          (0 _ : ConArgsNamed pCon) =>
+         Nat ->
          r) ->
     UniResults ->
     List r
   mapUCons f rs = do
     let adp = pushIn t.polyTy.cons t.polyTyNamed.tyConArgsNamed
-    let f' : List (Subset Con ConArgsNamed) -> UniResults -> List r
-        f' (Element con _ :: xs) (Success res :: ys) = f res con :: f' xs ys
-        f' (_ :: xs)             (_ :: ys)           = f' xs ys
-        f' _ _ = []
-    f' adp rs
+    let f' : List (Subset Con ConArgsNamed) -> UniResults -> Nat -> List r
+        f' (Element con _ :: xs) (Success res :: ys) n = f res con n :: f' xs ys (S n)
+        f' (_ :: xs)             (_ :: ys)           n = f' xs ys n
+        f' _ _ _ = []
+    f' adp rs 0
 
   ||| Run monadic operation on all pairs of specified and polymorphic constructors
   map2UConsN :
@@ -432,43 +503,41 @@ parameters (t : SpecTask)
          (0 _ : ConArgsNamed con) =>
          (mcon : Con) ->
          (0 _ : ConArgsNamed mcon) =>
+         ConMeta ->
          Nat ->
          r) ->
     UniResults ->
     (mt : TypeInfo) ->
     (0 _ : AllTyArgsNamed mt) =>
+    TypeMeta ->
     List r
-  map2UConsN f rs mt @{mtp} = do
+  map2UConsN f rs mt @{mtp} meta = do
     let p1 = pushIn t.polyTy.cons t.polyTyNamed.tyConArgsNamed
     let p2 = pushIn mt.cons mtp.tyConArgsNamed
-    f' 0 p1 p2 rs
+    f' 0 p1 p2 rs meta.conMeta
     where
       f' :
         Nat ->
         List (Subset Con ConArgsNamed) ->
         List (Subset Con ConArgsNamed) ->
         UniResults ->
+        List ConMeta ->
         List r
-      f' n (Element con _ :: xs) (Element mcon _ :: ys) (Success res :: zs) =
-        f res mt con mcon n :: f' (S n) xs ys zs
-      f' n (_             :: xs)                    ys  (_:: zs) =
-        f' n xs ys zs
-      f' _ _ _ _ = []
+      f' n (Element con _ :: xs) (Element mcon _ :: ys) (Success res :: zs) (meta' :: metas) =
+        f res mt con mcon meta' n :: f' (S n) xs ys zs metas
+      f' n (_             :: xs)                    ys  (_:: zs) ms =
+        f' n xs ys zs ms
+      f' _ _ _ _ _ = []
 
   -------------------------------
   --- CONSTRUCTOR UNIFICATION ---
   -------------------------------
 
   ||| Run unification for a given polymorphic constructor
-  unifyCon :
-    MonadLog m =>
-    (unifier : CanUnify m) =>
-    (con : Con) ->
-    (0 conN : ConArgsNamed con) =>
-    m UnificationVerdict
+  unifyCon : MonadLog m => (unifier : CanUnify m) => (con : Con) -> (0 conN : ConArgsNamed con) => m UnificationVerdict
   unifyCon con = logBounds Debug "specialiseData.unifyCon" [t.polyTy, con] $ do
-    let Element ca _ = allL2V con.args @{conArgsNamed}
-    let Element ta _ = allL2V t.tqArgs @{t.tqArgsNamed}
+    let Element ca _ = fromListAll con.args @{conArgsNamed}
+    let Element ta _ = fromListAll t.tqArgs @{t.tqArgsNamed}
     let uniTask =
       MkUniTask {lfv=_} ca con.type
                 {rfv=_} ta t.fullInvocation
@@ -482,10 +551,7 @@ parameters (t : SpecTask)
   ---------------------------------
 
   ||| Generate argument of a specified constructor
-  mkSpecArg :
-    (ur : UnificationResult) ->
-    Fin (ur.uniDg.freeVars) ->
-    (Subset Arg IsNamedArg)
+  mkSpecArg : (ur : UnificationResult) -> Fin (ur.uniDg.freeVars) -> Subset Arg IsNamedArg
   mkSpecArg ur fvId = do
     let fvData = index fvId ur.uniDg.fvData
     let fromLambda = finToNat fvId >= ur.task.lfv
@@ -493,49 +559,241 @@ parameters (t : SpecTask)
     let piInfo = if fromLambda && (fvData.piInfo == ExplicitArg) then ImplicitArg else fvData.piInfo
     Element (MkArg rig piInfo (Just fvData.name) fvData.type) ItIsNamed
 
+  getVar : TTImp -> Maybe Name
+  getVar (IVar _ n) = Just n
+  getVar _ = Nothing
+
+  ||| Check if a given argument is "recursive" (i.e. its type can be replaced with invocation of specialised type)
+  checkArgRecursion :
+    Monad m =>
+    CanUnify m =>
+    MonadLog m =>
+    NamesInfoInTypes =>
+    RecursionSearchState -> Subset Arg IsNamedArg -> m RecursionSearchState
+  checkArgRecursion rss (Element thisArg thisArgNamed) = do
+    let (MkRSS cRenames pToMRenames areArgsRec (Element argsForUni _) (Element argsOut _)) = rss
+    let (aLhs, aa) = unAppAny thisArg.type
+    let True = (length aa /= 0) || (isJust $ lookupType =<< getVar aLhs)
+      | False => do
+        let outPiInfo = substituteVariables cRenames <$> thisArg.piInfo
+        let outType = substituteVariables cRenames thisArg.type
+        let Element outArg outArgNamed =
+            Element (MkArg thisArg.count outPiInfo (Just $ argName thisArg) outType) ItIsNamed
+        pure $
+          MkRSS
+            cRenames
+            pToMRenames
+            (areArgsRec :< False)
+            (Element (snoc argsForUni thisArg) (snoc %search thisArgNamed))
+            (Element (argsOut :< outArg) (%search :< outArgNamed))
+    let Element ta _ = fromListAll t.tqArgs @{t.tqArgsNamed}
+    let uniTask = MkUniTask {lfv=_} argsForUni thisArg.type {rfv=_} ta t.fullInvocation
+    ur <- unify uniTask
+    case ur of
+      Success ur => do
+        let typeArgs = t.ttArgs.appsWith @{t.ttArgsNamed} var ur.fullResult
+        logPoint DetailedDebug "specialiseData.fra" [] $ show ur.fullResult
+        let tyRet = reAppAny (var t.resultName) typeArgs
+        logPoint DetailedDebug "specialiseData.fra" [] $ show tyRet
+        let mToPImpl = var $ inGenNS t "mToPImpl"
+        let pToMImpl = var $ inGenNS t "pToMImpl"
+        let outPiInfo = (\x => `(cast ~x)) . substituteVariables cRenames <$> thisArg.piInfo
+        let outType = substituteVariables cRenames tyRet
+        let Element outArg outArgNamed =
+            Element (MkArg thisArg.count outPiInfo (Just $ argName thisArg) outType) ItIsNamed
+        pure $
+          MkRSS
+            (insert (argName thisArg) `(~mToPImpl ~(var $ argName thisArg)) cRenames)
+            (insert (argName thisArg) `(~pToMImpl ~(var $ argName thisArg)) pToMRenames)
+            (areArgsRec :< True)
+            (Element (snoc argsForUni thisArg) (snoc %search thisArgNamed))
+            (Element (argsOut :< outArg) (%search :< outArgNamed))
+      _ => do
+        let outPiInfo = substituteVariables cRenames <$> thisArg.piInfo
+        let outType = substituteVariables cRenames thisArg.type
+        let Element outArg outArgNamed =
+            Element (MkArg thisArg.count outPiInfo (Just $ argName thisArg) outType) ItIsNamed
+        pure $
+          MkRSS
+            cRenames
+            pToMRenames
+            (areArgsRec :< False)
+            (Element (snoc argsForUni thisArg) (snoc %search thisArgNamed))
+            (Element (argsOut :< outArg) (%search :< outArgNamed))
+
   ||| Generate a specialised constructor
   mkSpecCon :
-    (newArgs : _) ->
+    Monad m =>
+    CanUnify m =>
+    MonadLog m =>
+    NamesInfoInTypes =>
+    (params : SpecialisationParams) =>
+    (newArgs : List Arg) ->
     (0 _ : All IsNamedArg newArgs) =>
     UnificationResult ->
     (con : Con) ->
     (0 _ : ConArgsNamed con) =>
-    Subset Con ConArgsNamed
-  mkSpecCon newArgs ur pCon = do
+    Nat ->
+    m $ (Subset Con ConArgsNamed, ConMeta)
+  mkSpecCon newArgs ur pCon cIdx = do
+    let specArgs = mkSpecArg ur <$> ur.order
     let Element args allArgs =
-      pullOut $ mkSpecArg ur <$> ur.order
+      pullOut specArgs
     let typeArgs = newArgs.appsWith var ur.fullResult
     let tyRet = reAppAny (var t.resultName) typeArgs
-    MkCon
-      { name = inGenNS t $ dropNS pCon.name
-      , args
-      , type = tyRet
-      } `Element` TheyAreNamed allArgs
+    let n = if params.eraseConNames then fromString "\{t.resultName}^Con^\{show cIdx}" else dropNS pCon.name
+    rssRhs <- foldlM checkArgRecursion (MkRSS empty empty [<] (Element [] []) (Element [<] [<])) specArgs
+    let (MkRSS mToPRenames pToMRenames argsAreRecursive' _ (Element outArgs' outArgsNamed')) = rssRhs
+    let Element outArgs outArgsNamed = toListAll outArgs' outArgsNamed'
+    let conMeta = MkCMeta (MkAMeta <$> toList argsAreRecursive') mToPRenames pToMRenames
+    pure $ (MkCon
+      { name = inGenNS t $ n
+      , args = outArgs
+      , type = substituteVariables mToPRenames tyRet
+      } `Element` TheyAreNamed outArgsNamed, conMeta)
 
   ||| Generate a specialised type
-  mkSpecTy : UniResults -> Subset TypeInfo AllTyArgsNamed
+  mkSpecTy :
+    Monad m => CanUnify m => MonadLog m =>
+    SpecialisationParams => NamesInfoInTypes =>
+    UniResults -> m $ (Subset TypeInfo AllTyArgsNamed, TypeMeta)
   mkSpecTy ur = do
-    let Element cons consAreNamed =
-      pullOut $ mapUCons (mkSpecCon t.ttArgs @{t.ttArgsNamed}) ur
-    MkTypeInfo
+    let 0 _ = t.ttArgsNamed
+    let muc = mapUCons (mkSpecCon t.ttArgs) ur
+    specConsMeta <- traverse id muc
+    let (specCons, specMeta) = unzip specConsMeta
+    let Element cons consAreNamed = pullOut specCons
+    pure $ (MkTypeInfo
       { name = inGenNS t t.resultName
       , args = t.ttArgs
       , cons
-      } `Element` TheyAllAreNamed t.ttArgsNamed consAreNamed
+      } `Element` TheyAllAreNamed t.ttArgsNamed consAreNamed, MkTyMeta specMeta)
 
-  ------------------------------------
-  --- POLY TO POLY CAST DERIVATION ---
-  ------------------------------------
+  mkSpecTySig : Decl
+  mkSpecTySig = iDataLater Public t.resultName (piAll type t.ttArgs)
 
+  ------------------------
+  --- CLAIM DERIVATION ---
+  ------------------------
   ||| Generate IPi with implicit type arguments and given return
   forallMTArgs : TTImp -> TTImp
   forallMTArgs = flip (foldr pi) $ makeTypeArgM0 . hideExplicitArg <$> t.ttArgs
 
+  applyMTArgs : TTImp -> TTImp
+  applyMTArgs =
+    flip (foldl (\x,arg => x .! (fromMaybe "" arg.name, var $ fromMaybe "" arg.name))) $
+      makeTypeArgM0 . hideExplicitArg <$> t.ttArgs
+
+  ||| Generate specialised to polimorphic type conversion function signature
+  mkMToPImplClaim : Decl
+  mkMToPImplClaim = public' "mToPImpl" $ forallMTArgs $ arg t.specInvocation .-> t.fullInvocation
+
+  ||| Generate specialised to polimorphic cast signature
+  mkMToPClaim : Decl
+  mkMToPClaim = interfaceHint Public "mToP" $ forallMTArgs $ `(Cast ~(t.specInvocation) ~(t.fullInvocation))
+
+  ||| Decidable equality signatures
+  mkDecEqImplClaim : Decl
+  mkDecEqImplClaim =
+    let tInv = t.specInvocation
+    in public' "decEqImpl" $ forallMTArgs $
+      piAll
+        `(Dec (Equal {a = ~tInv} {b = ~tInv} x1 x2))
+        [ MkArg MW AutoImplicit Nothing `(DecEq ~(t.fullInvocation))
+        , MkArg MW ExplicitArg (Just "x1") tInv
+        , MkArg MW ExplicitArg (Just "x2") tInv
+        ]
+
+  mkDecEqClaim : Decl
+  mkDecEqClaim = interfaceHint Public "decEq'" $ forallMTArgs `(DecEq ~(t.fullInvocation) => DecEq ~(t.specInvocation))
+
+  mkShowClaims : List Decl
+  mkShowClaims =
+    [ public' "showImpl" $
+      forallMTArgs
+        `(Show ~(t.fullInvocation) => ~(t.specInvocation) -> String)
+    , public' "showPrecImpl" $
+      forallMTArgs
+        `(Show ~(t.fullInvocation) => Prec -> ~(t.specInvocation) -> String)
+    , interfaceHint Public "show'" $ forallMTArgs $
+      `(Show ~(t.fullInvocation) => Show ~(t.specInvocation))
+    ]
+
+  mkEqClaims : List Decl
+  mkEqClaims = do
+    let tInv = t.specInvocation
+    [ public' "eqImpl" $ forallMTArgs
+        `(Eq ~(t.fullInvocation) => ~tInv -> ~tInv -> Bool)
+    , public' "neqImpl" $ forallMTArgs
+        `(Eq ~(t.fullInvocation) => ~tInv -> ~tInv -> Bool)
+    , interfaceHint Public "eq'" $ forallMTArgs $
+        `(Eq ~(t.fullInvocation) => Eq ~tInv)
+    ]
 
   ||| Generate specialised to polymorphic type conversion function signature
-  mkMToPImplSig : UniResults -> (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => TTImp
-  mkMToPImplSig _ mt =
-    forallMTArgs $ arg (mt.apply var empty) .-> t.fullInvocation
+  mkPToMImplClaim : Decl
+  mkPToMImplClaim = public' "pToMImpl" $ forallMTArgs $ arg t.fullInvocation .-> t.specInvocation
+
+  ||| Generate specialised to polimorphic cast signature
+  mkPToMClaim : Decl
+  mkPToMClaim =
+    interfaceHint Public "pToM" $ forallMTArgs $ `(Cast ~(t.fullInvocation) ~(t.specInvocation))
+
+  mkFromStringClaims : List Decl
+  mkFromStringClaims = do
+    let tInv = t.specInvocation
+    [ public' "fromStringImpl" $
+        forallMTArgs
+          `(FromString ~(t.fullInvocation) => String -> ~tInv)
+    , interfaceHint Public "fromString'" $
+        forallMTArgs `(FromString ~(t.fullInvocation) => FromString ~tInv)
+    ]
+
+  mkNumClaims : List Decl
+  mkNumClaims = do
+    let tInv = t.specInvocation
+    [ public' "numImpl" $
+        forallMTArgs
+          `(Num ~(t.fullInvocation) => Integer -> ~tInv)
+    , public' "plusImpl" $
+        forallMTArgs
+          `(Num ~(t.fullInvocation) => ~tInv -> ~tInv -> ~tInv)
+    , public' "starImpl" $
+        forallMTArgs
+          `(Num ~(t.fullInvocation) => ~tInv -> ~tInv -> ~tInv)
+    , interfaceHint Public "num'" $
+        forallMTArgs `(Num ~(t.fullInvocation) => Num ~tInv)
+    ]
+
+  standardClaims : List Decl
+  standardClaims =
+    [ mkMToPImplClaim
+    , mkMToPClaim
+    , mkDecEqImplClaim
+    , mkDecEqClaim
+    ] ++ join
+      [ mkShowClaims
+      , mkEqClaims
+      ]
+
+  decidedClaims : List Decl
+  decidedClaims =
+    [ mkPToMImplClaim
+    , mkPToMClaim
+    ] ++ join
+      [ mkFromStringClaims
+      , mkNumClaims
+      ]
+
+  ------------------------------------
+  --- POLY TO POLY CAST DERIVATION ---
+  ------------------------------------
+
+  transMachineVars : TTImp -> TTImp
+  transMachineVars $ IVar fc n@(MN ns nn) = IVar fc $ fromString "MS^\{show ns}^\{show nn}"
+  transMachineVars $ IBindVar fc n@(MN ns nn) = IBindVar fc $ fromString "MS^\{show ns}^\{show nn}"
+  transMachineVars t = t
+
 
   ||| Generate specialised to polymorphic type conversion function clause
   ||| for given constructor
@@ -547,134 +805,92 @@ parameters (t : SpecTask)
     (0 _ : ConArgsNamed pCon) =>
     (mCon : Con) ->
     (0 _ : ConArgsNamed mCon) =>
+    ConMeta ->
     Nat ->
     Clause
-  mkMToPImplClause ur _ con mcon _ =
-    var "mToPImpl" .$
-      mcon.apply bindVar
-        (substituteVariables
-          (fromList $ argsToBindMap mcon.args) <$> ur.fullResult)
-      .= con.apply var ur.fullResult
+  mkMToPImplClause ur _ con mcon meta _ =
+    mapClause transMachineVars $
+      var "mToPImpl" .$
+        mcon.apply bindVar
+          (substituteVariables
+            (fromList $ argsToBindMap mcon.args) <$> ur.fullResult)
+      .= (substituteVariables meta.mToPRenames $ con.apply var ur.fullResult)
 
   ||| Generate specialised to polymorphic type conversion function declarations
   mkMToPImplDecls :
     UniResults ->
     (mt : TypeInfo) ->
     (0 _ : AllTyArgsNamed mt) =>
+    TypeMeta ->
     List Decl
-  mkMToPImplDecls urs mt = do
-    let sig = mkMToPImplSig urs mt
-    let clauses = map2UConsN mkMToPImplClause urs mt
-    [ public' "mToPImpl" sig
-    , def "mToPImpl" clauses
+  mkMToPImplDecls urs mt meta = do
+    let clauses = map2UConsN mkMToPImplClause urs mt meta
+    [ def "mToPImpl" clauses
     ]
 
   ||| Generate specialised to polymorphic cast signature
   mkMToPSig : (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => TTImp
   mkMToPSig mt = do
-    forallMTArgs $ `(Cast ~(mt.apply var empty) ~(t.fullInvocation))
+    forallMTArgs $ `(Cast ~(t.specInvocation) ~(t.fullInvocation))
 
   ||| Generate specialised to polymorphic cast declarations
   mkMToPDecls : (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => List Decl
   mkMToPDecls mt =
-    [ interfaceHint Public "mToP" $ mkMToPSig mt
-    , def "mToP" [ (var "mToP") .= `(MkCast mToPImpl)]
+    [ def "mToP" [ (var "mToP") .= `(MkCast mToPImpl)]
     ]
 
   -----------------------------------
-  --- MULTIINJECTIVITY DERIVATION ---
+  --- CAST INJECTIVITY DERIVATION ---
   -----------------------------------
 
-  ||| Derive multiinjectivity for a polymorphic constructor that has a
-  ||| specialised equivalent
-  mkMultiInjDecl :
-    UnificationResult ->
-    (mt : TypeInfo) ->
-    (0 _ : AllTyArgsNamed mt) =>
-    (pCon : Con) ->
-    (0 _ : ConArgsNamed pCon) =>
-    (mCon : Con) ->
-    (0 mn : ConArgsNamed mCon) =>
-    Nat ->
-    List Decl
-  mkMultiInjDecl ur mt con mcon i = do
-    let S _ = length mcon.args
-    | _ => []
-    let n = fromString "mInj\{show i}"
-    let 0 _ = conArgsNamed @{mn}
-    let Element ourArgs _ = makeArgsImplicit mcon.args
-    let (Element a1 _, am1) = transformArgNames (prependS "lhs^") ourArgs
-    let (Element a2 _, am2) = transformArgNames (prependS "rhs^") ourArgs
-    let lhsCon = substituteVariables (fromList $ mapSnd var <$> am1) $
-                  con.apply var $ mergeAliases ur.fullResult am1
-    let rhsCon = substituteVariables (fromList $ mapSnd var <$> am2) $
-                  con.apply var $ mergeAliases ur.fullResult am2
-
-    let eqs = mkEqualsTuple $ zip (pushIn a1 %search) (pushIn a2 %search)
-    let sig =
-      flip piAll a1 $
-        flip piAll a2 $ `((~(lhsCon) ~=~ ~(rhsCon)) -> ~(eqs))
-    let lhs = mkDoubleBinds (cast $ zip a1 a2) (var n) .$ `(Refl)
-    [ public' n sig
-    , def n $ singleton $ patClause lhs $ tupleOfN (length mcon.args) `(Refl)
-    ]
+  ||| Emit a recursive call to castInjImpl constructing the proof from given names
+  recCastInj : Name -> Name -> TTImp
+  recCastInj p1 p2 = `(~(var $ inGenNS t $ "castInjImpl") $ trans ~(var p1) $ sym ~(var p2))
 
-  ||| Derive multiinjectivity for all polymorphic constructors that have
-  ||| a specialised equivalent
-  mkMultiInjDecls :
-    UniResults -> (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => List Decl
-  mkMultiInjDecls ur specTy = do
-    join $ map2UConsN mkMultiInjDecl ur specTy
-
-  ----------------------------------
-  --- MULTICONGRUENCY DERIVATION ---
-  ----------------------------------
+  ||| Generate a with-clause corresponding to a single recursive argument
+  mkArgWithClause : Name -> TTImp -> Clause -> Clause
+  mkArgWithClause argName existingLhs inner = do
+    let mToPImpl = var $ inGenNS t "mToPImpl"
+    let lhsArg = var $ fromString "lhs^\{argName}"
+    let rhsArg = var $ fromString "rhs^\{argName}"
+    let p1 = Just (MW, fromString "\{argName}^p1")
+    let p2 = Just (MW, fromString "\{argName}^p2")
+    withClause existingLhs MW `(~mToPImpl ~lhsArg) p1 [] [
+      withClause `(~existingLhs | _) MW `(~mToPImpl ~rhsArg) p2 [] [inner]
+    ]
 
-  ||| Derive multicongruency for a specialised constructor
-  |||
-  ||| mCongN : forall argsN, argsN'; conN argsN === conN argsN'
-  mkMultiCongDecl :
-    UnificationResult ->
-    (mt : TypeInfo) ->
-    (0 _ : AllTyArgsNamed mt) =>
-    (pCon : Con) ->
-    (0 _ : ConArgsNamed pCon) =>
-    (mCon : Con) ->
-    (0 mn : ConArgsNamed mCon) =>
-    Nat ->
-    List Decl
-  mkMultiCongDecl ur mt _ mcon i = do
-    let S _ = length mcon.args
-    | _ => []
-    let n = fromString "mCong\{show i}"
-    let 0 _ = conArgsNamed @{mn}
-    let Element ourArgs _ = makeArgsImplicit mcon.args
-    let (Element a1 _, am1) = transformArgNames (prependS "lhs^") ourArgs
-    let (Element a2 _, am2) = transformArgNames (prependS "rhs^") ourArgs
-    let lhsCon = mcon.apply var $ mergeAliases ur.fullResult am1
-    let rhsCon = mcon.apply var $ mergeAliases ur.fullResult am2
-    let eqs = mkEqualsTuple $ zip (pushIn a1 %search) (pushIn a2 %search)
-    let sig =
-      flip piAll a1 $ flip piAll a2 $ `(~(eqs) -> (~(lhsCon) ~=~ ~(rhsCon)))
-    let lhs = mkDoubleBinds (cast $ zip a1 a2) (var n) .$ tupleOfN (length mcon.args) `(Refl)
-    [ public' n sig
-    , def n $ singleton $ patClause lhs $ `(Refl)
+  ||| Wrap a term into a number of `IAppWith`s with underscores
+  withManyUnders : Nat -> TTImp -> TTImp
+  withManyUnders 0 x = x
+  withManyUnders (S n) x = withManyUnders n `(~x | _)
+
+  ||| Generate a final with-clause that matches all equality proofs to `Refl`s
+  mkFinalClause : (con : Con) -> (0 _ : ConArgsNamed con) => ConMeta -> Clause
+  mkFinalClause con meta = do
+    let emptyCon = con.apply (\_ => `(_)) empty
+    let recArgAmount = countRecursiveArgs meta
+    let initialLhs = withManyUnders (2 * recArgAmount) $
+      var "castInjImpl" .! ("castInj^x", emptyCon) .! ("castInj^y", emptyCon) .$ var "Refl"
+    let recNames = recursiveArgNames con meta
+    let recFns = (\n => recCastInj (fromString "\{n}^p1") (fromString "\{n}^p2")) <$> recNames
+    withClause initialLhs MW (tupleOf recFns) Nothing [] [
+      `(~initialLhs | ~(tupleOfN recArgAmount `(Refl))) .= `(Refl)
     ]
 
-  ||| Derive multicongruency for all specialised constructors
-  mkMultiCongDecls :
-    UniResults -> (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => List Decl
-  mkMultiCongDecls ur specTy = do
-    join $ map2UConsN mkMultiCongDecl ur specTy
+  ||| Generate a left-hand-side for recursive argument with-clauses
+  mkInitialLhs : Con -> ConMeta -> TTImp
+  mkInitialLhs con meta = do
+    let lhsCon = bindConRecArgsAliased con meta $ prependS "lhs^"
+    let rhsCon = bindConRecArgsAliased con meta $ prependS "rhs^"
+    var "castInjImpl" .! ("castInj^x", lhsCon) .! ("castInj^y", rhsCon) .$ bindVar "prf"
 
-  -----------------------------------
-  --- CAST INJECTIVITY DERIVATION ---
-  -----------------------------------
+  ||| Wrap a clause in with-clauses for all given names
+  mkRecArgClauses : List Name -> TTImp -> Clause -> Clause
+  mkRecArgClauses [] exLhs inner = inner
+  mkRecArgClauses (x :: xs) exLhs inner = mkArgWithClause x exLhs $ mkRecArgClauses xs `(~exLhs | _ | _) inner
 
-  ||| Make a clause for the cast injectivity proof
+  ||| Derive a single cast injectivity clause
   mkCastInjClause :
-    (tal1, tal2 : (List Arg, List (Name, Name))) ->
-    (n1, n2 : Name) ->
     UnificationResult ->
     (mt : TypeInfo) ->
     (0 _ : AllTyArgsNamed mt) =>
@@ -682,86 +898,66 @@ parameters (t : SpecTask)
     (0 cn : ConArgsNamed con) =>
     (mcon : Con) ->
     (0 mcn : ConArgsNamed mcon) =>
+    ConMeta ->
     Nat ->
     Clause
-  mkCastInjClause (ta1, tam1) (ta2, tam2) n1 n2 ur mt _ con n = do
-    let 0 _ = conArgsNamed @{mcn}
-    let (Element a1 _, am1) = transformArgNames (prependS "lhs^") con.args
-    let (Element a2 _, am2) = transformArgNames (prependS "rhs^") con.args
-    let am1' = fromList $ mapSnd (const `(_)) <$> am1
-    let am2' = fromList $ mapSnd (const `(_)) <$> am2
-    let ures1 = substituteVariables am1' <$> ur.fullResult
-    let ures2 = substituteVariables am2' <$> ur.fullResult
-    let bta1 = aliasedAppBind (cast tam1) `(castInjImpl)
-    let bta2 = aliasedAppBind (cast tam2) bta1
-    let lhsCon = con.apply bindVar $ am1'
-    let rhsCon = con.apply bindVar $ am1'
-    let patRhs : TTImp
-        patRhs = case (length a1) of
-          0 => `(Refl)
-          _ => (var $ inGenNS t $ fromString $ "mCong\{show n}") .$
-                ((var $ inGenNS t $ fromString $ "mInj\{show n}") .$ var "r")
-    bta2 .! (n1, lhsCon) .! (n2, rhsCon) .$ bindVar "r" .= patRhs
+  mkCastInjClause ur mt _ con meta n = do
+    if not (hasRecursiveArgs meta)
+      then do
+        let emptyCon = con.apply (\_ => `(_)) empty
+        (var "castInjImpl") .! ("castInj^x", emptyCon) .! ("castInj^y", emptyCon) .$ `(Refl) .= `(Refl)
+      else do
+        let finalClause = mkFinalClause con meta
+        let recNames = recursiveArgNames con meta
+        let initLhs = mkInitialLhs con meta
+        mkRecArgClauses recNames initLhs finalClause
 
   ||| Derive cast injectivity proof
   mkCastInjDecls :
     UniResults ->
     (mt : TypeInfo) ->
     (0 mtp : AllTyArgsNamed mt) =>
+    TypeMeta ->
     List Decl
-  mkCastInjDecls ur ti = do
-    let Element prepArgs prf = hideExplicitArgs ti.args @{mtp.tyArgsNamed}
-    let ta1@(Element a1 _, am1) = transformArgNames (prependS "lhs^") prepArgs
-    let ta2@(Element a2 _, am2) = transformArgNames (prependS "rhs^") prepArgs
+  mkCastInjDecls ur ti meta = do
     let xVar = "castInj^x"
     let yVar = "castInj^y"
     let mToPVar = var $ inGenNS t "mToP"
-    let mToPImplVar = var $ inGenNS t "mToPImpl"
+    let mToPImplVar = applyMTArgs $ var $ inGenNS t "mToPImpl"
     let arg1 = MkArg MW ImplicitArg (Just xVar) $
-                ti.apply var $ fromList $ mapSnd var <$> am1
+                ti.apply var empty
     let arg2 = MkArg MW ImplicitArg (Just yVar) $
-                ti.apply var $ fromList $ mapSnd var <$> am2
+                ti.apply var empty
     let eqs =
-      `((~(aliasedApp (cast am1) mToPImplVar .$ var xVar)
+      `((~(mToPImplVar .$ var xVar)
           ~=~
-          ~(aliasedApp (cast am2) $ mToPImplVar .$ var yVar)) ->
+          ~(mToPImplVar .$ var yVar)) ->
           ~(var xVar) ~=~ ~(var yVar))
-    let castInjImplClauses = map2UConsN (mkCastInjClause (a1, am1) (a2, am2) xVar yVar) ur ti
-    let tyArgPairs = cast $ zip ti.argNames ti.argNames
-    [ public' "castInjImpl" $
-        flip piAll (makeTypeArgM0 <$> a1) $
-          flip piAll (makeTypeArgM0 <$> a2) $
-            pi arg1 $ pi arg2 $ eqs
+    let castInjImplClauses = map2UConsN mkCastInjClause ur ti meta
+    [ claim M0 Public [] "castInjImpl" $ forallMTArgs $ pi arg1 $ pi arg2 $ eqs
     , def "castInjImpl" castInjImplClauses
-    , interfaceHint Public "castInj" $ forallMTArgs $
-        `(Injective ~(aliasedApp tyArgPairs mToPImplVar))
+    , claim M0 Public [Hint False] "castInj" $ forallMTArgs $
+        `(Injective ~(mToPImplVar))
     , def "castInj" $ singleton $
-        aliasedAppBind tyArgPairs `(castInj) .= `(MkInjective castInjImpl)
+        `(castInj) .= `(MkInjective castInjImpl)
     ]
 
   -------------------------------------
   --- DECIDABLE EQUALITY DERIVATION ---
   -------------------------------------
 
-  ||| Decidable equality signatures
-  mkDecEqImplSig : (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => TTImp
-  mkDecEqImplSig ti =
-    let tInv = ti.apply var empty
-    in forallMTArgs $
-      piAll
-        `(Dec (Equal {a = ~tInv} {b = ~tInv} x1 x2))
-        [ MkArg MW AutoImplicit Nothing `(DecEq ~(t.fullInvocation))
-        , MkArg MW ExplicitArg (Just "x1") tInv
-        , MkArg MW ExplicitArg (Just "x2") tInv
-        ]
-
   ||| Decidable equality clause
   mkDecEqImplClause : Clause
   mkDecEqImplClause =
     let mToPImpl = var $ inGenNS t "mToPImpl"
     in `(decEqImpl x1 x2)
-        .= `(decEqInj {f = ~mToPImpl} $ decEq (~mToPImpl x1) (~mToPImpl x2))
-
+        .=
+        `(decEqInj {f = ~mToPImpl} $
+          let x1' : ~(t.fullInvocation);
+              x1' = (~mToPImpl x1);
+              x2' : ~(t.fullInvocation);
+              x2' = (~mToPImpl x2);
+          in decEq x1' x2')
 
   ||| Derive decidable equality
   mkDecEqDecls :
@@ -770,10 +966,7 @@ parameters (t : SpecTask)
     (0 _ : AllTyArgsNamed mt) =>
     List Decl
   mkDecEqDecls _ ti = do
-    [ public' "decEqImpl" $ mkDecEqImplSig ti
-    , def "decEqImpl" [ mkDecEqImplClause ]
-    , interfaceHint Public "decEq'" $ forallMTArgs
-      `(DecEq ~(t.fullInvocation) => DecEq ~(ti.apply var empty))
+    [ def "decEqImpl" [ mkDecEqImplClause ]
     , def "decEq'"
       [ `(decEq') .= `((Mk DecEq) ~(var $ inGenNS t "decEqImpl")) ]
     ]
@@ -790,17 +983,9 @@ parameters (t : SpecTask)
     List Decl
   mkShowDecls _ ti = do
     let mToPImpl = var $ inGenNS t "mToPImpl"
-    [ public' "showImpl" $
-      forallMTArgs
-        `(Show ~(t.fullInvocation) => ~(ti.apply var empty) -> String)
-    , def "showImpl" [ `(showImpl x) .= `(show $ ~mToPImpl x) ]
-    , public' "showPrecImpl" $
-      forallMTArgs
-        `(Show ~(t.fullInvocation) => Prec -> ~(ti.apply var empty) -> String)
+    [ def "showImpl" [ `(showImpl x) .= `(show $ ~mToPImpl x) ]
     , def "showPrecImpl"
       [ `(showPrecImpl p x) .= `(showPrec p $ ~mToPImpl x) ]
-    , interfaceHint Public "show'" $ forallMTArgs $
-      `(Show ~(t.fullInvocation) => Show ~(ti.apply var empty))
     , def "show'" [ `(show') .= `(MkShow showImpl showPrecImpl) ]
     ]
 
@@ -816,17 +1001,8 @@ parameters (t : SpecTask)
     List Decl
   mkEqDecls _ ti = do
     let mToPImpl = var $ inGenNS t "mToPImpl"
-    let tInv = ti.apply var empty
-    [ public' "eqImpl" $
-      forallMTArgs
-        `(Eq ~(t.fullInvocation) => ~tInv -> ~tInv -> Bool)
-    , def "eqImpl" [ `(eqImpl x y) .= `((~mToPImpl x) == (~mToPImpl y)) ]
-    , public' "neqImpl" $
-      forallMTArgs
-        `(Eq ~(t.fullInvocation) => ~tInv -> ~tInv -> Bool)
+    [ def "eqImpl" [ `(eqImpl x y) .= `((~mToPImpl x) == (~mToPImpl y)) ]
     , def "neqImpl" [ `(neqImpl x y) .= `((~mToPImpl x) /= (~mToPImpl y)) ]
-    , interfaceHint Public "eq'" $ forallMTArgs $
-      `(Eq ~(t.fullInvocation) => Eq ~tInv)
     , def "eq'" [ `(eq') .= `(MkEq eqImpl neqImpl) ]
     ]
 
@@ -841,7 +1017,7 @@ parameters (t : SpecTask)
     (0 _ : AllTyArgsNamed mt) =>
     TTImp
   mkPToMImplSig _ mt =
-    forallMTArgs $ arg t.fullInvocation .-> mt.apply var empty
+    forallMTArgs $ arg t.fullInvocation .-> t.specInvocation
 
   ||| Generate specialised to polymorphic type conversion function clause
   ||| for given constructor
@@ -853,37 +1029,37 @@ parameters (t : SpecTask)
     (0 _ : ConArgsNamed pCon) =>
     (mCon : Con) ->
     (0 _ : ConArgsNamed mCon) =>
+    ConMeta ->
     Nat ->
     Clause
-  mkPToMImplClause ur _ con mcon _ =
-    var "pToMImpl" .$ con.apply bindVar
-      (substituteVariables
-        (fromList $ argsToBindMap $ con.args) <$> ur.fullResult)
-      .= mcon.apply var ur.fullResult
+  mkPToMImplClause ur _ con mcon meta _ =
+    mapClause transMachineVars $
+      var "pToMImpl" .$ con.apply bindVar
+        (substituteVariables
+          (fromList $ argsToBindMap $ con.args) <$> ur.fullResult)
+      .= (substituteVariables meta.pToMRenames $ mcon.apply var ur.fullResult)
 
   ||| Generate specialised to polymorphic type conversion function declarations
   mkPToMImplDecls :
     UniResults ->
     (mt : TypeInfo) ->
     (0 _ : AllTyArgsNamed mt) =>
+    TypeMeta ->
     List Decl
-  mkPToMImplDecls urs mt = do
-    let sig = mkPToMImplSig urs mt
-    let clauses = map2UConsN mkPToMImplClause urs mt
-    [ public' "pToMImpl" sig
-    , def "pToMImpl" clauses
+  mkPToMImplDecls urs mt meta = do
+    let clauses = map2UConsN mkPToMImplClause urs mt meta
+    [ def "pToMImpl" clauses
     ]
 
   ||| Generate specialised to polymorphic cast signature
   mkPToMSig : (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => TTImp
   mkPToMSig mt = do
-    forallMTArgs $ `(Cast ~(t.fullInvocation) ~(mt.apply var empty))
+    forallMTArgs $ `(Cast ~(t.fullInvocation) ~(t.specInvocation))
 
   ||| Generate specialised to polymorphic cast declarations
   mkPToMDecls : (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => List Decl
   mkPToMDecls mt =
-    [ interfaceHint Public "pToM" $ mkPToMSig mt
-    , def "pToM" [ (var "pToM") .= `(MkCast pToMImpl)]
+    [ def "pToM" [ (var "pToM") .= `(MkCast pToMImpl)]
     ]
 
   -----------------------------
@@ -896,14 +1072,8 @@ parameters (t : SpecTask)
     List Decl
   mkFromStringDecls ti = do
     let pToMImpl = var $ inGenNS t "pToMImpl"
-    let tInv = ti.apply var empty
-    [ public' "fromStringImpl" $
-        forallMTArgs
-          `(FromString ~(t.fullInvocation) => String -> ~tInv)
-    , def "fromStringImpl"
+    [ def "fromStringImpl"
       [ `(fromStringImpl @{fs} s) .= `(~pToMImpl $ fromString @{fs} s) ]
-    , interfaceHint Public "fromString'" $
-        forallMTArgs `(FromString ~(t.fullInvocation) => FromString ~tInv)
     , def "fromString'"
         [ `(fromString' @{fs}) .= `(MkFromString $ ~(var $ inGenNS t "fromStringImpl") @{fs}) ]
     ]
@@ -919,24 +1089,12 @@ parameters (t : SpecTask)
   mkNumDecls ti = do
     let pToMImpl = var $ inGenNS t "pToMImpl"
     let mToPImpl = var $ inGenNS t "mToPImpl"
-    let tInv = ti.apply var empty
-    [ public' "numImpl" $
-        forallMTArgs
-          `(Num ~(t.fullInvocation) => Integer -> ~tInv)
-    , def "numImpl"
+    [ def "numImpl"
       [ `(numImpl @{fs} s) .= `(~pToMImpl $ Num.fromInteger @{fs} s) ]
-    , public' "plusImpl" $
-        forallMTArgs
-          `(Num ~(t.fullInvocation) => ~tInv -> ~tInv -> ~tInv)
     , def "plusImpl"
         [ `(plusImpl @{fs} a b ) .= `(~pToMImpl $ (+) @{fs} (~mToPImpl a) (~mToPImpl b)) ]
-    , public' "starImpl" $
-        forallMTArgs
-          `(Num ~(t.fullInvocation) => ~tInv -> ~tInv -> ~tInv)
     , def "starImpl"
         [ `(starImpl @{fs} a b ) .= `(~pToMImpl $ (*) @{fs} (~mToPImpl a) (~mToPImpl b)) ]
-    , interfaceHint Public "num'" $
-        forallMTArgs `(Num ~(t.fullInvocation) => Num ~tInv)
     , def "num'"
         [ `(num' @{fs}) .=
             `(MkNum
@@ -951,98 +1109,92 @@ parameters (t : SpecTask)
   ------------------------------------
 
   ||| Generate declarations for given task, unification results, and specialised type
-  specDecls : MonadLog m => UniResults -> (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => m $ List Decl
-  specDecls uniResults specTy = do
+  specDecls : MonadLog m => UniResults -> (mt : TypeInfo) -> (0 _ : AllTyArgsNamed mt) => TypeMeta -> m $ List Decl
+  specDecls uniResults specTy specMeta = do
+    let specTySig = mkSpecTySig
     let specTyDecl = specTy.decl
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "specTyDecl : \{show specTyDecl}"
-    let mToPImplDecls = mkMToPImplDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "mToPImplDecls : \{show mToPImplDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.specTy.sig" [specTy] $ show mkSpecTySig
+    logPoint DetailedDebug "specialiseData.specDecls.specTy" [specTy] $ show specTyDecl
+    let mToPImplClaim = mkMToPImplClaim
+    let mToPImplDecls = mkMToPImplDecls uniResults specTy specMeta
+    logPoint DetailedDebug "specialiseData.specDecls.mToPImpl.sig" [specTy] $ show mToPImplClaim
+    logPoint DetailedDebug "specialiseData.specDecls.mToPImpl" [specTy] $ show mToPImplDecls
+    let mToPClaim = mkMToPClaim
     let mToPDecls = mkMToPDecls specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "mToP : \{show mToPDecls}"
-    let multiInjDecls = mkMultiInjDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "multiInj : \{show multiInjDecls}"
-    let multiCongDecls = mkMultiCongDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "multiCong : \{show multiCongDecls}"
-    let castInjDecls = mkCastInjDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "castInj : \{show castInjDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.mToP.sig" [specTy] $ show mToPClaim
+    logPoint DetailedDebug "specialiseData.specDecls.mToP" [specTy] $ show mToPDecls
+    let castInjDecls = mkCastInjDecls uniResults specTy specMeta
+    logPoint DetailedDebug "specialiseData.specDecls.castInj" [specTy] $ show castInjDecls
+    let decEqClaims : List Decl = [ mkDecEqImplClaim, mkDecEqClaim ]
     let decEqDecls = mkDecEqDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "decEq : \{show decEqDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.decEq.sig" [specTy] $ show decEqClaims
+    logPoint DetailedDebug "specialiseData.specDecls.decEq" [specTy] $ show decEqDecls
+    let showClaims = mkShowClaims
     let showDecls = mkShowDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "Show : \{show showDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.show.sig" [specTy] $ show showClaims
+    logPoint DetailedDebug "specialiseData.specDecls.show" [specTy] $ show showDecls
+    let eqClaims = mkEqClaims
     let eqDecls = mkEqDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "Eq : \{show eqDecls}"
-    let pToMImplDecls = mkPToMImplDecls uniResults specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "pToMImplDecls : \{show pToMImplDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.eq.sig" [specTy] $ show eqClaims
+    logPoint DetailedDebug "specialiseData.specDecls.eq" [specTy] $ show eqDecls
+    let pToMImplClaim = mkPToMImplClaim
+    let pToMImplDecls = mkPToMImplDecls uniResults specTy specMeta
+    logPoint DetailedDebug "specialiseData.specDecls.pToMImpl.sig" [specTy] $ show pToMImplClaim
+    logPoint DetailedDebug "specialiseData.specDecls.pToMImpl" [specTy] $ show pToMImplDecls
+    let pToMClaim = mkPToMClaim
     let pToMDecls = mkPToMDecls specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "pToM : \{show pToMDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.pToM.sig" [specTy] $ show pToMClaim
+    logPoint DetailedDebug "specialiseData.specDecls.pToM" [specTy] $ show pToMDecls
+    let fromStringClaims = mkFromStringClaims
     let fromStringDecls = mkFromStringDecls specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "fromString : \{show fromStringDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.fromString.sig" [specTy] $ show fromStringClaims
+    logPoint DetailedDebug "specialiseData.specDecls.fromString" [specTy] $ show fromStringDecls
+    let numClaims = mkNumClaims
     let numDecls = mkNumDecls specTy
-    logPoint DetailedDebug "specialiseData.specDecls" [specTy]
-      "num : \{show numDecls}"
+    logPoint DetailedDebug "specialiseData.specDecls.num.sig" [specTy] $ show numClaims
+    logPoint DetailedDebug "specialiseData.specDecls.num" [specTy] $ show numDecls
+    let anyUndecided = any isUndecided uniResults
+    let sClaims =
+        [ mToPImplClaim
+        , mToPClaim
+        ] ++ join
+          [ decEqClaims
+          , showClaims
+          , eqClaims
+          ]
+    let dClaims =
+        [ pToMImplClaim
+        , pToMClaim
+        ] ++ join
+          [ fromStringClaims
+          , numClaims
+          ]
+    let claims = sClaims ++ if anyUndecided then [] else dClaims
+    logPoint DetailedDebug "specialiseData.specDecls.claims" [specTy] $ show claims
+    let decidedDecls =
+      [ pToMImplDecls
+      , pToMDecls
+      , fromStringDecls
+      , numDecls
+      ]
     let onFull : List Decl =
-      if any isUndecided uniResults
+      if anyUndecided
           then []
-          else join
-            [ pToMImplDecls
-            , pToMDecls
-            , fromStringDecls
-            , numDecls
-            ]
+          else join decidedDecls
+
     pure $ singleton $ INamespace EmptyFC (MkNS [ show t.resultName ]) $
-      specTyDecl :: join
-        [ mToPImplDecls
+      join
+        [ [ mkSpecTySig ]
+        , claims
+        , [ specTyDecl ]
+        , mToPImplDecls
         , mToPDecls
-        , multiInjDecls
-        , multiCongDecls
         , castInjDecls
         , decEqDecls
         , showDecls
         , eqDecls
-        ] ++ onFull
-
--------------------------------------
---- SPECIALISATION TASK INTERFACE ---
--------------------------------------
-
-||| Valid task lambda interface
-|||
-||| Auto-implemented by any Type or any function that returns Type.
-export
-interface TaskLambda (t : Type) where
-
-export
-TaskLambda Type
-
-export
-TaskLambda b => TaskLambda (a -> b)
-
-export
-TaskLambda b => TaskLambda (a => b)
-
-export
-TaskLambda b => TaskLambda ({_ : a} -> b)
-
-export
-TaskLambda b => TaskLambda ((0 _ : a) -> b)
-
-export
-TaskLambda b => TaskLambda ((0 _ : a) => b)
-
-export
-TaskLambda b => TaskLambda ({0 _ : a} -> b)
+        , onFull
+        ]
 
 ---------------------------
 --- DATA SPECIALISATION ---
@@ -1067,6 +1219,7 @@ specialiseDataRaw :
   MonadLog m =>
   MonadError SpecialisationError m =>
   (namesInfo : NamesInfoInTypes) =>
+  SpecialisationParams =>
   (resultName : Name) ->
   (resultKind : TTImp) ->
   (resultContent : TTImp) ->
@@ -1077,10 +1230,98 @@ specialiseDataRaw resultName resultKind resultContent = do
   task <- getTask resultName resultKind resultContent
   logPoint DetailedDebug "specialiseData" [task.polyTy] "Specialisation task: \{show task}"
   uniResults <- sequence $ mapCons task $ unifyCon task
-  let Element specTy specTyNamed = mkSpecTy task uniResults
-  decls <- specDecls task uniResults specTy
+  (Element specTy specTyNamed, specMeta) <- mkSpecTy task uniResults
+  decls <- specDecls task uniResults specTy specMeta
   pure (specTy, decls)
 
+typeDPair : List Arg -> TTImp
+typeDPair [] = `(Type)
+typeDPair (x :: xs) = do
+  let aName = fromMaybe "" x.name
+  let aTyName = fromString "\{aName}^ty"
+  let tyArg = MkArg MW ExplicitArg (Just aTyName) `(Type)
+  let tyVar = var aTyName
+  let valArg = MkArg MW ExplicitArg (Just aName) tyVar
+  `(DPair Type ~(lam tyArg `(DPair ~tyVar ~(lam valArg $ typeDPair xs))))
+
+valDPair : SortedMap Name String ->  List Arg -> TTImp -> TTImp
+valDPair n2s [] x = x
+valDPair n2s (x :: xs) y = do
+  let aName = fromMaybe "" x.name
+  let aTyName = fromString "\{aName}^ty"
+  let tyVar = var aTyName
+  let valVar = var aName
+  let valHole = fromMaybe `(?) $ hole <$> lookup aName n2s
+  `(MkDPair ~(x.type) ~(iLet MW aName x.type valHole `(MkDPair ~valVar ~(valDPair n2s xs y))))
+
+unholeImpl : SortedMap String Name -> TTImp -> TTImp
+unholeImpl s2n (IHole fc holeName) =
+  case lookup holeName s2n of
+      Just vn => var vn
+      Nothing => IHole fc holeName
+unholeImpl s2n t = t
+
+unhole : SortedMap String Name -> TTImp -> TTImp
+unhole s2n = mapTTImp (unholeImpl s2n)
+
+unBadHoleImpl : TTImp -> TTImp
+unBadHoleImpl (IHole fc "_") = Implicit fc False
+unBadHoleImpl t = t
+
+unBadHole : TTImp -> TTImp
+unBadHole = mapTTImp unBadHoleImpl
+
+unMkDPair : TTImp -> List TTImp
+unMkDPair (IApp _ (IApp _ (INamedApp _ (INamedApp _ (IVar _ "Builtin.DPair.MkDPair") _ _) _ _) dl) dr) =
+  dl :: unMkDPair dr
+unMkDPair _ = []
+
+decodeDPair : Elaboration m => List Arg -> List TTImp -> m (List Arg)
+decodeDPair [] _ = pure []
+decodeDPair (a :: as) (aT :: _ :: ts) = pure $ ({type := aT} a) :: !(decodeDPair as ts)
+decodeDPair _ _ = fail "INTERNAL ERROR: Failed during lambda normalisation"
+
+genAliases : Elaboration m => List Arg -> m (SortedMap Name String, SortedMap String Name)
+genAliases = foldlM genAImpl (empty, empty)
+  where
+    genAImpl :
+      (SortedMap Name String, SortedMap String Name) ->
+      Arg ->
+      m (SortedMap Name String, SortedMap String Name)
+    genAImpl (n2s, s2n) a = do
+      randN <- genSym "lamArg"
+      let s = show randN
+      let n = fromMaybe "" a.name
+      pure (insert n s n2s, insert s n s2n)
+
+export
+normaliseTask : Elaboration m => List Arg -> TTImp -> m (TTImp, TTImp)
+normaliseTask lamArgs lamRhs = do
+  (n2s, s2n) <- genAliases lamArgs
+  nT : Type <- check $ unBadHole $ typeDPair lamArgs
+  nV : nT <- check $ unBadHole $ valDPair n2s lamArgs lamRhs
+  nVQ <- quote nV
+  newArgs <- decodeDPair lamArgs $ unMkDPair $ unBadHole $ unhole s2n nVQ
+  let newLamTy = piAll `(Type) newArgs
+  let newLam = foldr lam lamRhs newArgs
+  pure (newLamTy, newLam)
+
+export
+specialiseDataArgs :
+  Elaboration m =>
+  (nsProvider : NamespaceProvider m) =>
+  (unifier : CanUnify m) =>
+  MonadLog m =>
+  MonadError SpecialisationError m =>
+  (namesInfo : NamesInfoInTypes) =>
+  SpecialisationParams =>
+  (resultName : Name) ->
+  (lambdaArgs : List Arg) ->
+  (lambdaRHS : TTImp) ->
+  m (TypeInfo, List Decl)
+specialiseDataArgs resultName fvArgs lambdaRHS =
+  uncurry (specialiseDataRaw resultName) =<< normaliseTask fvArgs lambdaRHS
+
 ||| Perform a specialisation for a given type name and content lambda
 |||
 ||| In order to generate a specialised type declaration equivalent to the following type alias:
@@ -1093,18 +1334,19 @@ specialiseDataRaw resultName resultKind resultContent = do
 ||| specialiseData `{VF} $ \n => Fin n
 ||| ```
 export
-specialiseData :
-  TaskLambda taskT =>
+specialiseDataLam :
+  -- TaskLambda taskT =>
   Monad m =>
   Elaboration m =>
   (nsProvider : NamespaceProvider m) =>
   (unifier : CanUnify m) =>
   MonadError SpecialisationError m =>
   (namesInfo : NamesInfoInTypes) =>
+  SpecialisationParams =>
   (resultName : Name) ->
   (0 task : taskT) ->
   m (TypeInfo, List Decl)
-specialiseData resultName task = do
+specialiseDataLam resultName task = do
   -- Quote spec lambda type
   resultKind <- quote taskT
   -- Quote spec lambda
@@ -1122,23 +1364,24 @@ specialiseData resultName task = do
 ||| ```
 ||| ...you may use this function as follows:
 ||| ```
-||| specialiseData'' `{VF} $ \n => Fin n
+||| specialiseDataLam'' `{VF} $ \n => Fin n
 ||| ```
 export
-specialiseData'' :
+specialiseDataLam'' :
   Elaboration m =>
   (nsProvider : NamespaceProvider m) =>
   (unifier : CanUnify m) =>
-  TaskLambda taskT =>
+  SpecialisationParams =>
+  -- TaskLambda taskT =>
   Name ->
   (0 task: taskT) ->
   m $ List Decl
-specialiseData'' resultName task = do
+specialiseDataLam'' resultName task = do
   tq <- quote task
   nit <- getNamesInfoInTypes' tq
   Right (specTy, decls) <-
     runEitherT {m} {e=SpecialisationError} $
-      specialiseData resultName task
+      specialiseDataLam resultName task
   | Left err => fail "Specialisation error: \{show err}"
   pure decls
 
@@ -1152,16 +1395,17 @@ specialiseData'' resultName task = do
 ||| ```
 ||| ...you may use this function as follows:
 ||| ```
-||| %runElab specialiseData' `{VF} $ \n => Fin n
+||| %runElab specialiseDataLam' `{VF} $ \n => Fin n
 ||| ```
 export
-specialiseData' :
+specialiseDataLam' :
   Elaboration m =>
   (nsProvider : NamespaceProvider m) =>
   (unifier : CanUnify m) =>
-  TaskLambda taskT =>
+  SpecialisationParams =>
+  -- TaskLambda taskT =>
   Name ->
   (0 task: taskT) ->
   m ()
-specialiseData' resultName task =
-  specialiseData'' resultName task >>= declare
+specialiseDataLam' resultName task =
+  specialiseDataLam'' resultName task >>= declare
diff --git a/elab-util-extra/src/Language/Reflection/Compat.idr b/elab-util-extra/src/Language/Reflection/Compat.idr
index c4468d3ba..0ce76c110 100644
--- a/elab-util-extra/src/Language/Reflection/Compat.idr
+++ b/elab-util-extra/src/Language/Reflection/Compat.idr
@@ -10,6 +10,8 @@ import public Data.List1
 import public Data.String
 import public Data.Vect
 
+import public Deriving.Show
+
 import public Language.Reflection
 import Language.Reflection.Expr
 import Language.Reflection.Logging
@@ -18,6 +20,8 @@ import public Language.Reflection.Syntax.Ops
 
 %default total
 
+%language ElabReflection
+
 --------------------------------------------------------------------------------
 --          General Types
 --------------------------------------------------------------------------------
@@ -30,6 +34,34 @@ record Con where
   args : List Arg
   type : TTImp
 
+countShow : Show Count
+countShow = %runElab derive
+
+export
+Show Count where
+  show = show @{countShow}
+
+piInfoShow : Show a => Show (PiInfo a)
+piInfoShow = %runElab derive
+
+export
+Show a => Show (PiInfo a) where
+  show = show @{piInfoShow}
+
+argShow : Show Arg
+argShow = %runElab derive
+
+export
+Show Arg where
+  show = show @{argShow}
+
+conShow : Show Con
+conShow = %runElab derive
+
+export
+Show Con where
+  show = show @{conShow}
+
 ||| Tries to lookup a constructor by name.
 export
 getCon : Elaboration m => Name -> m Con
@@ -62,6 +94,13 @@ export
 LogPosition TypeInfo where
   logPosition = show . name
 
+tiShow : Show TypeInfo
+tiShow = %runElab derive
+
+export
+Show TypeInfo where
+  show = show @{tiShow}
+
 ||| Tries to get information about the data type specified
 ||| by name. The name need not be fully qualified, but
 ||| needs to be unambiguous.
diff --git a/elab-util-extra/src/Language/Reflection/Compat/TypeInfo.idr b/elab-util-extra/src/Language/Reflection/Compat/TypeInfo.idr
index 48e00fff0..1f256abac 100644
--- a/elab-util-extra/src/Language/Reflection/Compat/TypeInfo.idr
+++ b/elab-util-extra/src/Language/Reflection/Compat/TypeInfo.idr
@@ -24,8 +24,9 @@ typeCon ti = MkCon ti.name ti.args type
 export
 (.decl) : TypeInfo -> Decl
 (.decl) ti =
-  iData Public ti.name tySig [] conITys
+  iData Public tyName tySig [] conITys
   where
+    tyName = snd $ unNS ti.name
     tySig = piAll type ti.args
     conITys = (.iTy) <$> ti.cons
 
diff --git a/elab-util-extra/src/Language/Reflection/Unify/Interface.idr b/elab-util-extra/src/Language/Reflection/Unify/Interface.idr
index 42fbf1eca..6d4cfae92 100644
--- a/elab-util-extra/src/Language/Reflection/Unify/Interface.idr
+++ b/elab-util-extra/src/Language/Reflection/Unify/Interface.idr
@@ -5,13 +5,13 @@ import Data.Either
 import Data.Fin.Set
 import Data.SortedMap
 import Data.Vect
+import Data.Vect.Quantifiers
 import Decidable.Equality
-import Derive.Prelude
+import Deriving.Show
 import Language.Reflection
 import Language.Reflection.Expr
-import Language.Reflection.TTImp
-import Language.Reflection.TT
 import Language.Reflection.Syntax
+import Language.Reflection.Logging
 
 %language ElabReflection
 
@@ -38,9 +38,24 @@ record UnificationTask where
 
 %name UnificationTask task
 
-%runElab derive "Count" [Show]
-%runElab derive "PiInfo" [Show]
-%runElab derive "Syntax.Arg" [Show]
+sCount : Show Count
+sCount = %runElab derive
+
+Show Count where
+  show = show @{sCount}
+
+sPiInfo : Show a => Show (PiInfo a)
+sPiInfo = %runElab derive
+
+Show a => Show (PiInfo a) where
+  show = show @{sPiInfo}
+
+sArg : Show Arg
+sArg = %runElab derive
+
+Show Arg where
+  show = show @{sArg}
+
 
 export
 Show UnificationTask where
@@ -74,7 +89,17 @@ record FVData where
 
 %name FVData fv, fvData
 
-%runElab derive "FVData" [Show, Eq]
+sFVData : Show FVData
+sFVData = %runElab derive
+
+export
+Show FVData where
+  show = show @{sFVData}
+
+export
+Eq FVData where
+  (MkFVData name holeName rig piInfo type value) == (MkFVData name' holeName' rig' piInfo' type' value') =
+    name == name' && holeName == holeName' && rig == rig' && piInfo == piInfo' && type == type' && value == value'
 
 export
 Interpolation FVData where
@@ -137,7 +162,18 @@ record DependencyGraph where
 
 %name DependencyGraph dg, depGraph
 
-%runElab derive "DependencyGraph" [Show]
+export
+Show DependencyGraph where
+  showPrec p t =
+    showCon p "MkDG" $
+      joinBy "" $
+        [ showArg t.freeVars
+        , showArg t.fvData
+        , showArg t.fvDeps
+        , showArg t.empties
+        , showArg t.nameToId
+        , showArg t.holeToId
+        ]
 
 export
 Eq DependencyGraph where
@@ -164,7 +200,18 @@ record UnificationResult where
   ||| (specialised constructor arguments)
   order : List $ Fin uniDg.freeVars
 
-%runElab derive "UnificationResult" [Show]
+export
+Show UnificationResult where
+  showPrec p t =
+    showCon p "MkUR" $
+      joinBy "" $
+        [ showArg t.task
+        , showArg t.uniDg
+        , showArg t.lhsResult
+        , showArg t.rhsResult
+        , showArg t.fullResult
+        , showArg t.order
+        ]
 
 public export
 data UnificationError : Type where
@@ -174,7 +221,21 @@ data UnificationError : Type where
   ExtractionError : TTImp -> UnificationError
   NoUnificationError : UnificationError
 
-%runElab derive "UnificationError" [Show, Eq]
+sUE : Show UnificationError
+sUE = %runElab derive
+
+export
+Show UnificationError where
+  show = show @{sUE}
+
+export
+Eq UnificationError where
+  CatastrophicError == CatastrophicError = True
+  InternalError s == InternalError s' = s == s'
+  TargetTypeError t == TargetTypeError t' = t == t'
+  ExtractionError t == ExtractionError t' = t == t'
+  NoUnificationError == NoUnificationError = True
+  _ == _ = False
 
 public export
 data UnificationVerdict : Type where
@@ -182,7 +243,12 @@ data UnificationVerdict : Type where
   Undecided : UnificationVerdict
   Fail : UnificationError -> UnificationVerdict
 
-%runElab derive "UnificationVerdict" [Show]
+sUV : Show UnificationVerdict
+sUV = %runElab derive
+
+export
+Show UnificationVerdict where
+  show = show @{sUV}
 
 export %inline
 isSuccess : UnificationVerdict -> Bool
@@ -227,14 +293,14 @@ emptyLeaves : (dg : DependencyGraph) -> FinSet dg.freeVars
 emptyLeaves dg = intersection dg.empties $ leaves dg
 
 ||| List all the free variables without a value in order of dependency
-flattenEmpties : (dg : DependencyGraph) -> SnocList $ Fin dg.freeVars
+flattenEmpties : Monad m => (dg : DependencyGraph) -> m $ SnocList $ Fin dg.freeVars
 flattenEmpties dg = flattenEmpties' dg [<]
   where
-    flattenEmpties' : (dg : DependencyGraph) -> SnocList (Fin dg.freeVars) -> SnocList $ Fin dg.freeVars
+    flattenEmpties' : (dg : DependencyGraph) -> SnocList (Fin dg.freeVars) -> m $ SnocList $ Fin dg.freeVars
     flattenEmpties' dg@(MkDG {freeVars, fvData, fvDeps, empties, nameToId, holeToId}) ctx = do
-      let els = emptyLeaves dg
+      els <- pure $ id $ emptyLeaves dg
       let False = null els
-      | _ => ctx
+      | _ => pure ctx
       -- Now els is a non-empty subset of dg.empties
       flattenEmpties'
         -- `assert_smaller dg` is a workaround for a non-working `assert_smaller empties`
@@ -259,12 +325,12 @@ filterEmpty = foldl myfun []
 
 ||| Calculate UnificationResult (var-to-value mappings and empty leaf dependency order)
 export
-finalizeDG : (task : UnificationTask) -> (dg : DependencyGraph) -> UnificationResult
+finalizeDG : Monad m => MonadLog m => (task : UnificationTask) -> (dg : DependencyGraph) -> m UnificationResult
 finalizeDG task dg = do
-  let fvOrder = flattenEmpties dg
-  let urList = filterEmpty dg.fvData
-  let (lhsRL, rhsRL) = List.splitAt task.lfv urList
-  MkUR
+  fvOrder <- flattenEmpties dg
+  urList <- pure $ id $ filterEmpty dg.fvData
+  (lhsRL, rhsRL) <- pure $ id $ List.splitAt task.lfv urList
+  pure $ MkUR
     { task
     , uniDg = dg
     , lhsResult = fromList lhsRL
diff --git a/elab-util-extra/src/Language/Reflection/Unify/WithCompiler.idr b/elab-util-extra/src/Language/Reflection/Unify/WithCompiler.idr
index 59489ceba..4a1d5d2ca 100644
--- a/elab-util-extra/src/Language/Reflection/Unify/WithCompiler.idr
+++ b/elab-util-extra/src/Language/Reflection/Unify/WithCompiler.idr
@@ -1,20 +1,20 @@
 module Language.Reflection.Unify.WithCompiler
 
-import Control.Monad.Either
-import Control.Monad.Writer
-import Control.Monad.Identity
+import public Control.Monad.Either -- workaround for compiler bug
+import public Control.Monad.Writer  -- workaround for compiler bug
+import public Control.Monad.Identity  -- workaround for compiler bug
 import Data.DPair
 import Data.Fin.Set
 import Data.Vect
-import Data.Vect.Quantifiers
-import Data.SnocVect
+import public Data.Vect.Quantifiers  -- workaround for compiler bug
+import public Data.SnocVect  -- workaround for compiler bug
 import Data.SortedMap
-import Decidable.Equality
+import public Decidable.Equality  -- workaround for compiler bug
 import Language.Reflection
-import Language.Reflection.Expr
-import Language.Reflection.Logging
+import public Language.Reflection.Expr  -- workaround for compiler bug
+import public Language.Reflection.Logging  -- workaround for compiler bug
 import Language.Reflection.Syntax
-import Language.Reflection.Unify.Interface
+import public Language.Reflection.Unify.Interface
 import Language.Reflection.VarSubst
 
 %default total
@@ -216,10 +216,10 @@ solveDG :
   (dg : DependencyGraph) ->
   m DependencyGraph
 solveDG dg = do
-  let cs = canSub dg
+  cs <- pure $ id $ canSub dg
   let False = null cs
   | _ => pure dg
-  ds <- pure $ doSub dg cs
+  ds <- pure $ id $ doSub dg cs
   -- DG <= DS because cs is non-empty, and every doSub may shrink the set of possibly substitutable variables
   -- If doSub can't shrink it, the dependency graph stays the same
   if ds == dg
@@ -356,7 +356,7 @@ unifyWithCompiler task = do
   let err = pure {f=Elab} $ Left $ Just CatastrophicError
   rr <- try ret err
   dg <- liftEither rr
-  ur <- pure $ finalizeDG task dg
+  ur <- finalizeDG task dg
   logPoint DetailedDebug "unifyWithCompiler" [] "Unification result: \{show ur}"
   pure ur
 
@@ -369,7 +369,7 @@ unifyWithCompiler' :
   m $ UnificationResult
 unifyWithCompiler' task = do
   dg <- unify' task
-  pure $ finalizeDG task dg
+  finalizeDG task dg
 
 export
 [UnifyWithCompiler]
diff --git a/elab-util-extra/src/Language/Reflection/VarSubst.idr b/elab-util-extra/src/Language/Reflection/VarSubst.idr
index 8c85450cc..fb0a829a2 100644
--- a/elab-util-extra/src/Language/Reflection/VarSubst.idr
+++ b/elab-util-extra/src/Language/Reflection/VarSubst.idr
@@ -8,8 +8,8 @@ import Language.Reflection.TTImp
 import Language.Reflection.TT
 import Language.Reflection.Util
 import Control.Monad.Identity
-import Control.Monad.Reader
-import Control.Monad.Reader.Tuple
+import public Control.Monad.Reader -- workaround for compiler bug
+import public Control.Monad.Reader.Tuple -- workaround for compiler bug
 import Control.Monad.State
 
 %default total
diff --git a/elab-util-extra/tests/pack.toml b/elab-util-extra/tests/pack.toml
index 60b22c210..0a9d447ab 100644
--- a/elab-util-extra/tests/pack.toml
+++ b/elab-util-extra/tests/pack.toml
@@ -3,7 +3,3 @@ type = "local"
 path = "unify-with-compiler/_shared"
 ipkg = "unifywc-shared.ipkg"
 
-[custom.all.specdata-shared]
-type = "local"
-path = "specialise-data/_shared"
-ipkg = "specdata-shared.ipkg"
diff --git a/elab-util-extra/tests/specialise-data/_shared/Shared.idr b/elab-util-extra/tests/specialise-data/_shared/Shared.idr
index 031847c57..ec045b3fc 100644
--- a/elab-util-extra/tests/specialise-data/_shared/Shared.idr
+++ b/elab-util-extra/tests/specialise-data/_shared/Shared.idr
@@ -1,45 +1,7 @@
 module Shared
 
-import public Control.Monad.Either
-import public Control.Monad.Error.Either
-import public Control.Monad.Error.Interface
-import public Control.Monad.Writer
-import public Control.Monad.Identity
-import public Control.Monad.Trans
-import public Control.Monad.Reader.Reader
-import public Control.Monad.Reader.Interface
-import public Control.Monad.Reader.Tuple
-import public Control.Monad.State
-import public Data.DPair
-import public Data.Either
-import public Data.List
-import public Data.List.Map
-import public Data.List.Quantifiers
-import public Data.Maybe
-import public Data.SnocVect
-import public Data.SortedSet
-import public Data.SortedMap.Dependent
-import public Data.Vect
-import public Data.Vect.Quantifiers
-import public Decidable.Decidable
-import public Decidable.Equality
-import public Derive.Prelude
 import public Deriving.SpecialiseData
-import public Language.Mk
-import public Language.Reflection
-import public Language.Reflection.Compat
-import public Language.Reflection.Compat.Constr
-import public Language.Reflection.Compat.TypeInfo
-import public Language.Reflection.Derive
-import public Language.Reflection.Expr
-import public Language.Reflection.Logging
-import public Language.Reflection.Syntax
-import public Language.Reflection.Syntax.Ops
-import public Language.Reflection.TTImp
-import public Language.Reflection.TT
-import public Language.Reflection.Types
 import public Language.Reflection.Unify
-import public Language.Reflection.VarSubst
 
 ||| Verify that all values in list check to a given type
 constructExprs : Type -> List TTImp -> Elab ()
diff --git a/elab-util-extra/tests/specialise-data/_shared/specdata-shared.ipkg b/elab-util-extra/tests/specialise-data/_shared/specdata-shared.ipkg
deleted file mode 100644
index b5552f5bf..000000000
--- a/elab-util-extra/tests/specialise-data/_shared/specdata-shared.ipkg
+++ /dev/null
@@ -1,5 +0,0 @@
-package specdata-shared
-
-depends = elab-util-extra
-
-modules = Shared
diff --git a/elab-util-extra/tests/specialise-data/_shared/test.ipkg b/elab-util-extra/tests/specialise-data/_shared/test.ipkg
new file mode 100644
index 000000000..abef6abfd
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/_shared/test.ipkg
@@ -0,0 +1,6 @@
+package test
+
+opts = "--no-color --console-width 0"
+
+depends = elab-util-extra
+
diff --git a/elab-util-extra/tests/specialise-data/_shared/test/test.ipkg b/elab-util-extra/tests/specialise-data/_shared/test/test.ipkg
index effb38a7a..abef6abfd 100644
--- a/elab-util-extra/tests/specialise-data/_shared/test/test.ipkg
+++ b/elab-util-extra/tests/specialise-data/_shared/test/test.ipkg
@@ -2,5 +2,5 @@ package test
 
 opts = "--no-color --console-width 0"
 
-depends = specdata-shared, elab-util-extra
+depends = elab-util-extra
 
diff --git a/elab-util-extra/tests/specialise-data/specdata-001-listNat/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-001-listNat/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-001-listNat/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-001-listNat/Test.idr b/elab-util-extra/tests/specialise-data/specdata-001-listNat/Test.idr
index 51e98798c..e66de7e99 100644
--- a/elab-util-extra/tests/specialise-data/specdata-001-listNat/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-001-listNat/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "ListNat" $ List Nat
+%runElab specialiseDataLam' "ListNat" $ List Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 ln' = %runElab verifySpecialisation (List Nat) ListNat
@@ -26,7 +26,7 @@ failing "Can't find an implementation for FromString Nat"
   ln1 : ListNat
   ln1 = ["test"]
 
-%runElab specialiseData' "ListListString" (List (List String))
+%runElab specialiseDataLam' "ListListString" (List (List String))
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 lss' = %runElab verifySpecialisation (List (List String)) ListListString
@@ -45,7 +45,7 @@ lss'' = %runElab verifyInvalidConstructors (List (List String)) ListListString
   , `( [[1,2],[3,4]] )
   ]
 
-%runElab specialiseData' "ListType" (List Type)
+%runElab specialiseDataLam' "ListType" (List Type)
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 lt' = %runElab verifySpecialisation (List Type) ListType
diff --git a/elab-util-extra/tests/specialise-data/specdata-001-listNat/expected b/elab-util-extra/tests/specialise-data/specdata-001-listNat/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-001-listNat/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-001-listNat/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Test.idr b/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Test.idr
index d6fe593e2..b32cf8002 100644
--- a/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "MFin" $ \a => Maybe $ Fin a
+%runElab specialiseDataLam' "MFin" $ \a => Maybe $ Fin a
 
 mFin0NoJust : MFin 0 -> Unit
 mFin0NoJust (Nothing) = MkUnit
diff --git a/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/expected b/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-002-maybeFin/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Test.idr b/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Test.idr
index 00e11dcb6..ceb80ff8c 100644
--- a/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "ListVectNat" $ \a => List $ Vect a Nat
+%runElab specialiseDataLam' "ListVectNat" $ \a => List $ Vect a Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 lvn0' = %runElab verifySpecialisation (List $ Vect 0 Nat) (ListVectNat 0)
diff --git a/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/expected b/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-003-listVectNat/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-004-list/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-004-list/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-004-list/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-004-list/Test.idr b/elab-util-extra/tests/specialise-data/specdata-004-list/Test.idr
index 92630361a..ee25aedec 100644
--- a/elab-util-extra/tests/specialise-data/specdata-004-list/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-004-list/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "MyList" $ \a => List a
+%runElab specialiseDataLam' "MyList" $ \a => List a
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 l0' = %runElab verifySpecialisation (List Nat) (MyList Nat)
diff --git a/elab-util-extra/tests/specialise-data/specdata-004-list/expected b/elab-util-extra/tests/specialise-data/specdata-004-list/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-004-list/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-004-list/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-005-vect/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-005-vect/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-005-vect/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-005-vect/Test.idr b/elab-util-extra/tests/specialise-data/specdata-005-vect/Test.idr
index 8ee36c68c..1352ad6b9 100644
--- a/elab-util-extra/tests/specialise-data/specdata-005-vect/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-005-vect/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "MyVect" $ \n, a => Vect n a
+%runElab specialiseDataLam' "MyVect" $ \n, a => Vect n a
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 v0' = %runElab verifySpecialisation (Vect 0 Nat) (MyVect 0 Nat) [`([])]
@@ -26,7 +26,7 @@ v2' = %runElab verifySpecialisation (Vect 1 String) (MyVect 1 String)
   ]
 
 
-%runElab specialiseData' "FlipVect" $ \a, n => Vect n a
+%runElab specialiseDataLam' "FlipVect" $ \a, n => Vect n a
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 fv0' = %runElab verifySpecialisation (Vect 0 Nat) (FlipVect Nat 0) [`([])]
diff --git a/elab-util-extra/tests/specialise-data/specdata-005-vect/expected b/elab-util-extra/tests/specialise-data/specdata-005-vect/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-005-vect/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-005-vect/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Test.idr b/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Test.idr
index 43b840ef2..ef0ec8d5f 100644
--- a/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "EitherVoid" $ \a => Either Void a
+%runElab specialiseDataLam' "EitherVoid" $ \a => Either Void a
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifySpecialisation (Either Void Nat) (EitherVoid Nat)
diff --git a/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/expected b/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-006-eitherVoid/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Test.idr b/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Test.idr
index 685cc1660..0e143fbb1 100644
--- a/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-007-vectConst/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "Vect0" (\a => Vect 0 a)
+%runElab specialiseDataLam' "Vect0" (\a => Vect 0 a)
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifySpecialisation (Vect 0 Nat) (Vect0 Nat) [`([])]
@@ -12,7 +12,7 @@ e0' = %runElab verifySpecialisation (Vect 0 Nat) (Vect0 Nat) [`([])]
 e0NoCons : Vect0 Nat -> Nat
 e0NoCons [] = 0
 
-%runElab specialiseData' "Vect2" $ \a => Vect 2 a
+%runElab specialiseDataLam' "Vect2" $ \a => Vect 2 a
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e1' = %runElab verifySpecialisation (Vect 2 Nat) (Vect2 Nat)
@@ -21,7 +21,7 @@ e1' = %runElab verifySpecialisation (Vect 2 Nat) (Vect2 Nat)
   , `( [2, 1] )
   ]
 
-%runElab specialiseData' "VectString" $ \a => Vect a String
+%runElab specialiseDataLam' "VectString" $ \a => Vect a String
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e2' = %runElab verifySpecialisation (Vect 0 String) (VectString 0)
diff --git a/elab-util-extra/tests/specialise-data/specdata-007-vectConst/expected b/elab-util-extra/tests/specialise-data/specdata-007-vectConst/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-007-vectConst/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-007-vectConst/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Test.idr b/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Test.idr
index 60417ffcd..c7455e22a 100644
--- a/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/Test.idr
@@ -8,7 +8,7 @@ data X : (Nat -> Type) -> Type where
   X5 : t 5 -> X t
   Xn : t n -> X t
 
-%runElab specialiseData' "XFin" $ X Fin
+%runElab specialiseDataLam' "XFin" $ X Fin
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 x0' = %runElab verifySpecialisation (X Fin) XFin
@@ -21,7 +21,7 @@ x0' = %runElab verifySpecialisation (X Fin) XFin
   , `(Xn (the (Fin 6) 3))
   ]
 
-%runElab specialiseData' "XVNat" $ X (\n => Vect n Nat)
+%runElab specialiseDataLam' "XVNat" $ X (\n => Vect n Nat)
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 x1' = %runElab verifySpecialisation (X (\n => Vect n Nat)) XVNat
@@ -33,7 +33,7 @@ x1' = %runElab verifySpecialisation (X (\n => Vect n Nat)) XVNat
   ]
 
 
-%runElab specialiseData' "XVFin" $ X (\n => Vect n $ Fin n)
+%runElab specialiseDataLam' "XVFin" $ X (\n => Vect n $ Fin n)
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 x2' = %runElab verifySpecialisation (X (\n => Vect n $ Fin n)) XVFin
diff --git a/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/expected b/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-008-depOnArg/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-009-finConst/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-009-finConst/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-009-finConst/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-009-finConst/Test.idr b/elab-util-extra/tests/specialise-data/specdata-009-finConst/Test.idr
index d79d1a0de..c9b636b01 100644
--- a/elab-util-extra/tests/specialise-data/specdata-009-finConst/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-009-finConst/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "Fin0" $ Fin 0
+%runElab specialiseDataLam' "Fin0" $ Fin 0
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifySpecialisation (Fin 0) Fin0 []
@@ -16,14 +16,14 @@ e0NoCons _ impossible
 e0'' = %runElab verifyEmptyType (Fin 0) Fin0
 
 
-%runElab specialiseData' "Fin1" $ Fin 1
+%runElab specialiseDataLam' "Fin1" $ Fin 1
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e1' = %runElab verifySpecialisation (Fin 1) Fin1
   [ `( FZ )
   ]
 
-%runElab specialiseData' "Fin2" $ Fin 2
+%runElab specialiseDataLam' "Fin2" $ Fin 2
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e2' = %runElab verifySpecialisation (Fin 2) Fin2
diff --git a/elab-util-extra/tests/specialise-data/specdata-009-finConst/expected b/elab-util-extra/tests/specialise-data/specdata-009-finConst/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-009-finConst/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-009-finConst/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-010-name/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-010-name/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-010-name/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-010-name/Test.idr b/elab-util-extra/tests/specialise-data/specdata-010-name/Test.idr
index 367f158ad..d6b0125c2 100644
--- a/elab-util-extra/tests/specialise-data/specdata-010-name/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-010-name/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "MyName" Name
+%runElab specialiseDataLam' "MyName" Name
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifySpecialisation Name MyName
diff --git a/elab-util-extra/tests/specialise-data/specdata-010-name/expected b/elab-util-extra/tests/specialise-data/specdata-010-name/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-010-name/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-010-name/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-011-nat/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-011-nat/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-011-nat/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-011-nat/Test.idr b/elab-util-extra/tests/specialise-data/specdata-011-nat/Test.idr
index 4a6dd6a0f..b05b91a0b 100644
--- a/elab-util-extra/tests/specialise-data/specdata-011-nat/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-011-nat/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "MyNat" Nat
+%runElab specialiseDataLam' "MyNat" Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifySpecialisation Nat MyNat
diff --git a/elab-util-extra/tests/specialise-data/specdata-011-nat/expected b/elab-util-extra/tests/specialise-data/specdata-011-nat/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-011-nat/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-011-nat/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-012-void/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-012-void/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-012-void/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-012-void/Test.idr b/elab-util-extra/tests/specialise-data/specdata-012-void/Test.idr
index 29dbdd6ee..260f9f262 100644
--- a/elab-util-extra/tests/specialise-data/specdata-012-void/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-012-void/Test.idr
@@ -4,7 +4,7 @@ import Shared
 
 %language ElabReflection
 
-%runElab specialiseData' "MyVoid" Void
+%runElab specialiseDataLam' "MyVoid" Void
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifyEmptyType Void MyVoid
diff --git a/elab-util-extra/tests/specialise-data/specdata-012-void/expected b/elab-util-extra/tests/specialise-data/specdata-012-void/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-012-void/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-012-void/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Test.idr b/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Test.idr
index 19d70427b..17ca0d96d 100644
--- a/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-013-vectSum/Test.idr
@@ -9,7 +9,7 @@ import Shared
 --- This is not the desired behaviour. Once we implement unifyManually and fording,
 --- It should be possible to represent such constructors using condition auto-implicits.
 
-%runElab specialiseData' "VectSum" $ \a,b => Vect (a + b) Nat
+%runElab specialiseDataLam' "VectSum" $ \a,b => Vect (a + b) Nat
 
 failing "x _ is not a valid impossible case."
   x : Vect (a + b) Nat -> Nat
diff --git a/elab-util-extra/tests/specialise-data/specdata-013-vectSum/expected b/elab-util-extra/tests/specialise-data/specdata-013-vectSum/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-013-vectSum/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-013-vectSum/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Test.idr b/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Test.idr
index f2a032ed9..b12e25a7e 100644
--- a/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data Y : (Type -> Type) -> Type where
   MkY : Functor f => f Nat -> Y f
 
-%runElab specialiseData' "Y'" $ Y List
+%runElab specialiseDataLam' "Y'" $ Y List
 
 y0 : Y'
 y0 = MkY []
diff --git a/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/expected b/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-014-autoImplicitInArg/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Test.idr b/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Test.idr
index 7b56cbcd7..c2eca23c2 100644
--- a/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data Z : Type -> Type where
   MkZ : Semigroup x => (a, b : x) -> (f : x -> Type) -> f (a <+> b) -> Z x
 
-%runElab specialiseData' "Z'" $ Z (List Nat)
+%runElab specialiseDataLam' "Z'" $ Z (List Nat)
 
 z0 : Z'
 z0 = MkZ [0] [1, 2] (Any $ \x => x = 0) (Here Refl)
diff --git a/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/expected b/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-015-autoImplicitInArg2/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Test.idr b/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Test.idr
index dc45b19d6..11da7c460 100644
--- a/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data X : Type -> (Type -> Type) -> Type where
   MkX : f a -> f Nat -> f String -> f (f a) -> X a f
 
-%runElab specialiseData' "X'" $ X (Fin 5) List
+%runElab specialiseDataLam' "X'" $ X (Fin 5) List
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 x0' = %runElab verifySpecialisation (X (Fin 5) List) X'
diff --git a/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/expected b/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-016-higherKindedType/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Test.idr b/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Test.idr
index 40a8488fb..73c51aa66 100644
--- a/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data V : Type where
   MkV : (0 n : Nat) -> {default 0 p : Fin (S n)} -> V
 
-%runElab specialiseData' "V'" V
+%runElab specialiseDataLam' "V'" V
 
 v0 : V'
 v0 = MkV 10
diff --git a/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/expected b/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-017-defaultInArgConst/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Test.idr b/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Test.idr
index 4f6a6eaf8..197334f70 100644
--- a/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data W : Type where
   MkW : (0 n : Nat) -> (k : Fin (S n)) -> {default k p : Fin (S n)} -> W
 
-%runElab specialiseData' "W'" W
+%runElab specialiseDataLam' "W'" W
 
 w0 : W'
 w0 = MkW 10 5
diff --git a/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/expected b/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-018-defaultInArgVal/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Test.idr b/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Test.idr
index 1c6aa7236..30014208d 100644
--- a/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data X : Nat -> Type where
   MkX : {0 n : Nat} -> {default 0 p : Fin (S n)} -> X (S n)
 
-%runElab specialiseData' "X'" $ X 2
+%runElab specialiseDataLam' "X'" $ X 2
 
 x0 : X'
 x0 = MkX
diff --git a/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/expected b/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-019-defaultInArgDep/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Test.idr b/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Test.idr
index a9f8208eb..3caf9b47c 100644
--- a/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data Y : Type -> Type where
   MkY : Monoid x => {default neutral p : x} -> Y x
 
-%runElab specialiseData' "Y'" $ Y String
+%runElab specialiseDataLam' "Y'" $ Y String
 
 y0 : Y'
 y0 = MkY
@@ -15,7 +15,7 @@ y0 = MkY
 y1 : Y'
 y1 = MkY {p="Hello world"}
 
-%runElab specialiseData' "Y''" $ Y Nat
+%runElab specialiseDataLam' "Y''" $ Y Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifyEmptyType (Y Nat) Y''
diff --git a/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/expected b/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-020-defaultInArgDep2/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Test.idr b/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Test.idr
index 8c81cc2fb..c35995493 100644
--- a/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-021-eqTy/Test.idr
@@ -6,9 +6,9 @@ import Shared
 
 -- The specialiser in its current form does *not* support type aliases!
 failing "MissingTypeInfoError Builtin.(===)"
-  %runElab specialiseData' "EqNat" $ \x => x = Nat
+  %runElab specialiseDataLam' "EqNat" $ \x => x = Nat
 
-%runElab specialiseData' "EqNatMW" $ \x : Type => Builtin.Equal x Nat
+%runElab specialiseDataLam' "EqNatMW" $ \x : Type => Builtin.Equal x Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0' = %runElab verifySpecialisation (Nat = Nat) (EqNatMW Nat) [`(Refl)]
@@ -16,7 +16,7 @@ e0' = %runElab verifySpecialisation (Nat = Nat) (EqNatMW Nat) [`(Refl)]
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e0'' = %runElab verifyEmptyType (String === Nat) (EqNatMW String)
 
-%runElab specialiseData' "EqNatM0" $ \0 x : Type => Builtin.Equal x Nat
+%runElab specialiseDataLam' "EqNatM0" $ \0 x : Type => Builtin.Equal x Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e1' = %runElab verifySpecialisation (Nat = Nat) (EqNatM0 Nat) [`(Refl)]
@@ -24,12 +24,12 @@ e1' = %runElab verifySpecialisation (Nat = Nat) (EqNatM0 Nat) [`(Refl)]
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e1'' = %runElab verifyEmptyType (String === Nat) (EqNatM0 String)
 
-%runElab specialiseData' "EqNat2" $ Builtin.Equal Nat Nat
+%runElab specialiseDataLam' "EqNat2" $ Builtin.Equal Nat Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e2' = %runElab verifySpecialisation (Nat = Nat) (EqNat2) [`(Refl)]
 
-%runElab specialiseData' "EqNat3" $ Builtin.Equal String Nat
+%runElab specialiseDataLam' "EqNat3" $ Builtin.Equal String Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e2'' = %runElab verifyEmptyType (String === Nat) (EqNat3)
diff --git a/elab-util-extra/tests/specialise-data/specdata-021-eqTy/expected b/elab-util-extra/tests/specialise-data/specdata-021-eqTy/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-021-eqTy/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-021-eqTy/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Test.idr b/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Test.idr
index 6279b2bec..3f999346e 100644
--- a/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-022-eqVal/Test.idr
@@ -6,15 +6,15 @@ import Shared
 
 -- The specialiser in its current form does *not* support type aliases!
 failing "MissingTypeInfoError Builtin.(===)"
-  %runElab specialiseData' "Eq3" $ \x => x = 3
+  %runElab specialiseDataLam' "Eq3" $ \x => x = 3
 
-%runElab specialiseData' "Eq3'" $ \x : Nat => Builtin.Equal x 3
+%runElab specialiseDataLam' "Eq3'" $ \x : Nat => Builtin.Equal x 3
 
 failing "Mismatch between: ?x = ?x and Eq3' 3."
   e0 : Eq3' 3
   e0 = Refl
 
-%runElab specialiseData' "Eq3" $ \x : Nat => Builtin.Equal x (the Nat 3)
+%runElab specialiseDataLam' "Eq3" $ \x : Nat => Builtin.Equal x (the Nat 3)
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 e1' = %runElab verifySpecialisation
diff --git a/elab-util-extra/tests/specialise-data/specdata-022-eqVal/expected b/elab-util-extra/tests/specialise-data/specdata-022-eqVal/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-022-eqVal/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-022-eqVal/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Test.idr b/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Test.idr
index 317ac5895..57da5dba8 100644
--- a/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/Test.idr
@@ -7,7 +7,7 @@ import Shared
 data X : Type -> Type -> Type where
   MkX : (t, f : Type) -> X t f
 
-%runElab specialiseData' "X'" $ \x => X x Nat
+%runElab specialiseDataLam' "X'" $ \x => X x Nat
 
 --- The variable assignment is a workaround for https://github.com/idris-lang/Idris2/issues/3651
 x1' = %runElab verifySpecialisation' (X Nat Nat) (X' Nat)
diff --git a/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/expected b/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-023-omegaTy/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-024-customNS/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-024-customNS/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-024-customNS/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-024-customNS/Test.idr b/elab-util-extra/tests/specialise-data/specdata-024-customNS/Test.idr
index c0c9d5ba0..8ce5dd365 100644
--- a/elab-util-extra/tests/specialise-data/specdata-024-customNS/Test.idr
+++ b/elab-util-extra/tests/specialise-data/specdata-024-customNS/Test.idr
@@ -5,7 +5,7 @@ import public Shared
 %language ElabReflection
 
 decls : List Decl
-decls = %runElab specialiseData'' {nsProvider = inNS $ MkNS ["Custom", "Test"]} {unifier = DefaultUnifier} "MyNat" Nat
+decls = %runElab specialiseDataLam'' {nsProvider = inNS $ MkNS ["Custom", "Test"]} {unifier = DefaultUnifier} "MyNat" Nat
 
 namespace Custom
   %runElab declare decls
diff --git a/elab-util-extra/tests/specialise-data/specdata-024-customNS/expected b/elab-util-extra/tests/specialise-data/specdata-024-customNS/expected
index 31e5db7f3..4a77231de 100644
--- a/elab-util-extra/tests/specialise-data/specdata-024-customNS/expected
+++ b/elab-util-extra/tests/specialise-data/specdata-024-customNS/expected
@@ -1 +1,2 @@
-1/1: Building Test (Test.idr)
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/Test.idr b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/Test.idr
new file mode 100644
index 000000000..717474bfc
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/Test.idr
@@ -0,0 +1,14 @@
+module Test
+
+import Shared
+
+%default total
+
+%language ElabReflection
+
+data Y : Type -> Type where
+  MkY : Either Nat a -> Y a
+
+%runElab specialiseDataLam' "EitherSpec" $ \a, b => Either Nat (Y (Either (Fin a) b))
+
+%runElab specialiseDataLam' "EitherSpec2" $ \a, b => EitherSpec a b
diff --git a/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/expected b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/expected
new file mode 100644
index 000000000..4a77231de
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/expected
@@ -0,0 +1,2 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/run b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/run
new file mode 120000
index 000000000..64c976f45
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/run
@@ -0,0 +1 @@
+../_shared/run
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/test.ipkg b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/test.ipkg
new file mode 120000
index 000000000..f5e58508a
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-025-lamCollision/test.ipkg
@@ -0,0 +1 @@
+../_shared/test/test.ipkg
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/Test.idr b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/Test.idr
new file mode 100644
index 000000000..c4fed899c
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/Test.idr
@@ -0,0 +1,12 @@
+module Test
+
+import Shared
+
+%default total
+
+%language ElabReflection
+
+data X : (n : Nat) -> Fin n -> Type where
+  MkX : X 5 4
+
+%runElab specialiseDataLam' "Y" $ \a, b => X a b
diff --git a/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/expected b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/expected
new file mode 100644
index 000000000..4a77231de
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/expected
@@ -0,0 +1,2 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/run b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/run
new file mode 120000
index 000000000..64c976f45
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/run
@@ -0,0 +1 @@
+../_shared/run
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/test.ipkg b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/test.ipkg
new file mode 120000
index 000000000..f5e58508a
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-026-depInLambda/test.ipkg
@@ -0,0 +1 @@
+../_shared/test/test.ipkg
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/Test.idr b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/Test.idr
new file mode 100644
index 000000000..8c082c676
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/Test.idr
@@ -0,0 +1,34 @@
+module Test
+
+import Shared
+
+%default total
+
+%language ElabReflection
+
+public export
+data Lookup : a -> List (a, b) -> Type where
+  Here : (y : b) -> Lookup x $ (x, y)::xys
+  There : Lookup z xys -> Lookup z $ (x, y)::xys
+
+public export
+data Type' = Bool' | Int' | String'
+
+
+
+%runElab do
+  let task =
+    \ x =>
+        \ y =>
+          Lookup
+            {b = Builtin.Pair String (Type', Type')}
+            {a = Type'}
+            x
+            y
+  qtask <- quote task
+  let (lArgs, lRhs) = unLambda qtask
+  (nlt', nl') <- normaliseTask lArgs lRhs
+  nlt : Type <- check nlt'
+  nl : nlt <- check nl'
+  specialiseDataLam' "Y" nl
+
diff --git a/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/expected b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/expected
new file mode 100644
index 000000000..4a77231de
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/expected
@@ -0,0 +1,2 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/run b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/run
new file mode 120000
index 000000000..64c976f45
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/run
@@ -0,0 +1 @@
+../_shared/run
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/test.ipkg b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/test.ipkg
new file mode 120000
index 000000000..f5e58508a
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-027-reproPilReg/test.ipkg
@@ -0,0 +1 @@
+../_shared/test/test.ipkg
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/Shared.idr b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/Shared.idr
new file mode 120000
index 000000000..988e6e0ff
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/Shared.idr
@@ -0,0 +1 @@
+../_shared/Shared.idr
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/Test.idr b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/Test.idr
new file mode 100644
index 000000000..82b619452
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/Test.idr
@@ -0,0 +1,27 @@
+module Test
+
+import Shared
+
+%language ElabReflection
+
+public export
+data Lookup : a -> List (a, b) -> Type where
+  Here : {0 type_of_x : Type} -> {0 x : type_of_x} -> {0 b : Type} ->
+         {0 xys : List (type_of_x, b)} -> (y : b) ->
+         Lookup {b} {a = type_of_x} x ((::) {a = (type_of_x, b)} (MkPair {a = type_of_x} {b} x y) xys)
+  There : {0 b : Type} -> {0 a : Type} -> {0 x : a} -> {0 y : b} -> {0 z : a} ->
+          {0 xys : List (a, b)} -> Lookup {b} {a} z xys ->
+          Lookup {b} {a} z ((::) {a = (a, b)} (MkPair {a} {b} x y) xys)
+
+public export
+data IsReveal : Lookup {a} {b} x xys -> b -> Type where
+  IsHere : IsReveal (Here y) y
+  IsThere : IsReveal subl y -> IsReveal (There subl) y
+
+export
+data Name = MkName String
+
+public export
+data Type' = Bool' | Int' | String'
+
+%runElab specialiseDataLam' "IsRevealName" $ \ 0 l0 => \ 0 l1 => \ l2 => \ l3 => Test.IsReveal {a = Test.Name} {x = l0} {b = Type'} {xys = l1} l2 l3
diff --git a/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/expected b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/expected
new file mode 100644
index 000000000..4a77231de
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/expected
@@ -0,0 +1,2 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
diff --git a/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/run b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/run
new file mode 120000
index 000000000..64c976f45
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/run
@@ -0,0 +1 @@
+../_shared/run
\ No newline at end of file
diff --git a/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/test.ipkg b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/test.ipkg
new file mode 120000
index 000000000..f5e58508a
--- /dev/null
+++ b/elab-util-extra/tests/specialise-data/specdata-028-reproPilReg2/test.ipkg
@@ -0,0 +1 @@
+../_shared/test/test.ipkg
\ No newline at end of file
diff --git a/elab-util-extra/tests/unify-with-compiler/_shared/Shared.idr b/elab-util-extra/tests/unify-with-compiler/_shared/Shared.idr
index a6d6fa71f..f3f2eee2a 100644
--- a/elab-util-extra/tests/unify-with-compiler/_shared/Shared.idr
+++ b/elab-util-extra/tests/unify-with-compiler/_shared/Shared.idr
@@ -1,19 +1,5 @@
 module Shared
 
-import public Control.Monad.Either
-import public Control.Monad.Writer
-import public Control.Monad.Identity
-import public Decidable.Equality
-import public Data.DPair
-import public Data.Vect
-import public Data.SnocVect
-import public Data.Vect.Quantifiers
-import public Derive.Prelude
-import public Language.Reflection
-import public Language.Reflection.Derive
-import public Language.Reflection.Expr
-import public Language.Reflection.Logging
-import public Language.Reflection.Syntax
 import public Language.Reflection.Unify
 
 public export
diff --git a/examples/pil-dyn/src/Language/PilDyn.idr b/examples/pil-dyn/src/Language/PilDyn.idr
index 173a00469..b53154c42 100644
--- a/examples/pil-dyn/src/Language/PilDyn.idr
+++ b/examples/pil-dyn/src/Language/PilDyn.idr
@@ -2,6 +2,8 @@ module Language.PilDyn
 
 import public Data.Fin
 import Data.String
+import public Data.Vect
+import public Data.Vect.AtIndex
 
 import Decidable.Equality
 
@@ -22,43 +24,12 @@ DecEq Ty where
   decEq B I = No $ \Refl impossible
 
 public export
-data MaybeTy = Nothing | Just Ty
-
-export
-Injective PilDyn.Just where
-  injective Refl = Refl
-
-export
-DecEq MaybeTy where
-  decEq Nothing Nothing = Yes Refl
-  decEq (Just x) (Just y) = decEqCong $ decEq x y
-  decEq Nothing (Just _) = No $ \Refl impossible
-  decEq (Just _) Nothing = No $ \Refl impossible
-
-namespace Regs
-  public export
-  data Regs : Nat -> Type where
-    Nil  : Regs 0
-    (::) : MaybeTy -> Regs n -> Regs $ S n
-
-export
-Biinjective Regs.(::) where
-  biinjective Refl = (Refl, Refl)
-
-export
-DecEq (Regs n) where
-  decEq [] [] = Yes Refl
-  decEq (x::xs) (y::ys) = decEqCong2 (decEq x y) (decEq xs ys)
-
-public export
-update : Fin r -> MaybeTy -> Regs r -> Regs r
-update FZ     t (x::xs) = t :: xs
-update (FS i) t (x::xs) = x :: update i t xs
+Regs : Nat -> Type
+Regs n = Vect n $ Maybe Ty
 
 public export
-data RegIsType : Fin r -> Ty -> Regs r -> Type where
-  Here  : RegIsType FZ t (Just t :: rest)
-  There : RegIsType i t rest -> RegIsType (FS i) t (reg :: rest)
+RegIsType : Fin r -> Ty -> Regs r -> Type
+RegIsType fn t rs = AtIndex fn rs (Just t)
 
 -------------------
 --- Expressions ---
@@ -119,7 +90,7 @@ data LinBlock : (ins, outs : Regs r) -> Type where
 
   Assign : (target : Fin r) ->
            (expr : Expr ins t) ->
-           (cont : LinBlock (update target (Just t) ins) outs) ->
+           (cont : LinBlock (replaceAt target (Just t) ins) outs) ->
            LinBlock ins outs
 
 --- Linear block DSL ---
@@ -131,7 +102,7 @@ data Assignment : (target : _) -> (ins : _) -> (t : _) -> Type where
 export infix 2 #=
 
 public export %inline
-(>>) : Assignment target ins t -> LinBlock (update target (Just t) ins) outs -> LinBlock ins outs
+(>>) : Assignment target ins t -> LinBlock (replaceAt target (Just t) ins) outs -> LinBlock ins outs
 target #= expr >> cont = Assign target expr cont
 
 export
@@ -153,7 +124,7 @@ Interpolation Ty where
   interpolate B = "B"
 
 export
-Interpolation MaybeTy where
+Interpolation (Maybe Ty) where
   interpolate $ Just t = "\{t}"
   interpolate Nothing  = "?"
 
diff --git a/examples/pil-dyn/tests/gens/all-given/expected b/examples/pil-dyn/tests/gens/all-given/expected
index 6c15e1209..b6088a7cb 100644
--- a/examples/pil-dyn/tests/gens/all-given/expected
+++ b/examples/pil-dyn/tests/gens/all-given/expected
@@ -9,64 +9,64 @@ Both inputs and outputs are given
 [1] := [0] * 31
 [0] := 7 < 5
 -------------------------
-[1] := [3] * [3]
-[3] := [3] + -19
-[3] := [0] * 0
-[0] := [2] || T
+[1] := -35 * [3]
+[3] := [3] + [3]
+[3] := [3] + 0
+[0] := [2]
 [3] := [2] && [2]
 -------------------------
+[1] := [2]
+[1] := [3] * 7
+[3] := [0] < -24
+[3] := [1] + -23
+[3] := [2] && F
 [0] := F
-[1] := [3] + [3]
-[3] := [2] && [0]
-[3] := [1] + -24
-[2] := ![2]
-[3] := [2]
 -------------------------
-[3] := [2]
-[1] := [3]
-[2] := 15 + [0]
-[1] := 24 * -38
-[2] := [3]
-[0] := [2] || [3]
+[3] := F && F
+[3] := [3]
+[1] := [3] && F
+[1] := [0] * [0]
+[1] := [1] + -3
+[0] := [0] == 15
 -------------------------
-[2] := [3] * [3]
-[3] := T
-[2] := -21 * [2]
-[1] := 0 + 20
+[3] := [3] * [3]
+[0] := -21 * [3]
 [2] := F
+[1] := 0
+[3] := [3] < -39
 [0] := [3]
 -------------------------
-[3] := [3] + [3]
-[3] := [3] * -18
+[3] := -18
+[3] := [3] * -28
 [3] := [2]
 [1] := -6
 [1] := [1]
 [0] := F || [2]
 -------------------------
-[2] := [2] == [2]
-[1] := -37 < 37
-[3] := T && [2]
-[3] := T && [3]
-[1] := 7 + 26
-[0] := T
+[2] := [3]
+[2] := [3] + [2]
+[1] := -28
+[2] := T && T
+[3] := 7 == 26
+[0] := [3]
 -------------------------
-[3] := F
-[1] := [3]
+[3] := ![2]
+[0] := T
+[3] := [0]
+[1] := 35
 [1] := F
-[3] := [3]
-[1] := -40 * 29
-[0] := [0] == 28
+[1] := -18
 -------------------------
-[0] := 19 * [3]
-[1] := [2] && [2]
-[2] := !T
+[0] := [3] + [3]
+[1] := 10
+[2] := [2]
+[1] := [3]
 [3] := F
-[1] := [0] * [0]
-[0] := ![3]
+[0] := F
 -------------------------
-[1] := -22 + [3]
-[1] := [2]
-[1] := 31 < [3]
-[3] := T && F
-[0] := [1] || T
-[1] := -21
+[3] := [3] + [3]
+[3] := [3] * [3]
+[2] := [2]
+[3] := [2]
+[1] := 8
+[0] := F
diff --git a/examples/pil-dyn/tests/gens/ins-given/expected b/examples/pil-dyn/tests/gens/ins-given/expected
index a570240db..e2980994e 100644
--- a/examples/pil-dyn/tests/gens/ins-given/expected
+++ b/examples/pil-dyn/tests/gens/ins-given/expected
@@ -3,75 +3,71 @@ Now compiling the executable: test
 Input registers state is given
 -------------------------
 -- outputs: I, I, I, B
-[2] := 35 * 34
-[1] := [2] < 13
+[2] := [3]
+[1] := F
 [1] := [3]
 [3] := T
 -------------------------
--- outputs: ?, ?, ?, I
-[2] := -35 * [3]
-[3] := [3] + [3]
-[3] := 0
-[0] := T == T
-[2] := [0] || F
-[1] := T || [2]
+-- outputs: B, ?, ?, I
+[3] := [3]
+[3] := [3]
+[0] := [2] == T
+[1] := [3] + 0
+[0] := [3] < [1]
+[2] := [2] || F
 -------------------------
--- outputs: B, B, B, ?
-[0] := [3] == [3]
-[1] := [3] + [3]
-[3] := [2]
-[3] := [1]
-[1] := -20 < -12
+-- outputs: I, ?, ?, I
+[1] := !T
 -------------------------
--- outputs: ?, I, ?, ?
-[0] := T == T
-[3] := [2]
-[3] := [3] && F
-[1] := -14 < -5
-[1] := -33 * -28
-[3] := [1]
--------------------------
--- outputs: ?, ?, I, ?
-[3] := -19
+-- outputs: I, ?, B, ?
+[3] := T || F
+[3] := 23 * [0]
+[3] := [3] == -39
 [2] := [3]
-[3] := T && T
-[2] := 20
-[3] := 0
-[1] := [3] < -39
+[0] := [0] * [0]
+[1] := -24 == [0]
 -------------------------
--- outputs: ?, I, ?, ?
-[3] := -18
-[3] := 27 + [3]
-[3] := ![2]
-[2] := -40 == [0]
-[3] := T
-[1] := [0]
--------------------------
--- outputs: I, ?, I, ?
-[2] := [0] * 7
-[2] := [3]
-[1] := -1 + 14
-[3] := T
+-- outputs: B, I, ?, ?
+[3] := [3]
+[3] := [2]
+[0] := F
+[3] := T == T
+[3] := -30
+[1] := 36
 -------------------------
--- outputs: I, B, ?, B
-[2] := [0] * [0]
-[3] := !T
-[3] := -10
-[2] := [3] == [3]
-[3] := [2] && T
+-- outputs: I, I, B, ?
 [1] := [3]
+[3] := 26
+[3] := 11 * [0]
+[2] := T
+[3] := [3] + -35
+[3] := [2]
 -------------------------
--- outputs: I, ?, B, ?
-[2] := [2]
+-- outputs: ?, I, B, ?
+[3] := T || [2]
 [2] := [2]
-[0] := -38
-[1] := [3]
-[2] := ![2]
+[3] := F && F
+[3] := [0] * [0]
+[3] := [2]
+[1] := -6
 -------------------------
--- outputs: I, ?, B, I
+-- outputs: ?, B, B, ?
+[1] := [2]
 [3] := [2]
-[3] := -29 == [0]
-[3] := [0]
-[3] := 24
-[2] := [2]
-[1] := T
+[3] := [0] * -37
+[3] := [2]
+[3] := F && T
+[0] := 35 == 19
+-------------------------
+-- outputs: ?, ?, B, ?
+[1] := [3] == [3]
+[3] := T
+[1] := F
+[1] := F || T
+-------------------------
+-- outputs: ?, ?, B, ?
+[2] := [3] * 27
+[2] := [3] * [3]
+[2] := T == T
+[1] := 15
+[1] := F && F
diff --git a/examples/pil-dyn/tests/gens/no-given/expected b/examples/pil-dyn/tests/gens/no-given/expected
index a1789f076..2cacfadef 100644
--- a/examples/pil-dyn/tests/gens/no-given/expected
+++ b/examples/pil-dyn/tests/gens/no-given/expected
@@ -2,76 +2,85 @@
 Now compiling the executable: test
 No register state is given
 -------------------------
--- inputs:  ?, B, ?, B
+-- inputs:  ?, B, ?, I
 -- outputs: ?, ?, I, I
-[0] := 4
-[3] := [3] || F
+[0] := -33
+[3] := [1] || F
 [3] := -8 + 39
 [3] := 37
 [0] := F
 [2] := 35 + 34
 -------------------------
--- inputs:  ?, B, I, I
--- outputs: I, ?, ?, I
-[2] := [2] + [3]
-[3] := [1]
-[1] := !T
-[3] := -6 + [2]
-[0] := -27
-[3] := [3] * -21
+-- inputs:  I, B, ?, B
+-- outputs: ?, B, B, I
+[3] := 35
+[3] := T
+[2] := [1]
+[1] := [3] || [3]
+[3] := [0]
 -------------------------
--- inputs:  ?, ?, ?, B
--- outputs: ?, ?, B, B
-[3] := -12
-[0] := -17
-[3] := T == T
-[2] := T
-[0] := [0] == [0]
-[1] := T
+-- inputs:  ?, I, ?, ?
+-- outputs: ?, B, B, B
+[1] := 22
+[3] := F
+[3] := [3]
+[1] := [1] == 2
+[2] := -11 == -12
+[0] := -29 + 35
 -------------------------
--- inputs:  ?, B, B, I
--- outputs: ?, ?, ?, ?
-[1] := T
-[0] := [2]
+-- inputs:  B, I, I, B
+-- outputs: ?, ?, I, B
 -------------------------
--- inputs:  ?, ?, B, B
--- outputs: I, ?, ?, ?
-[3] := ![3]
-[3] := -39
+-- inputs:  ?, B, I, I
+-- outputs: I, ?, I, ?
+[3] := [2] < [3]
+[3] := [2] + [2]
+[1] := [1] && F
+[3] := -30 + 28
+[3] := 20 + [3]
+[0] := -19
+-------------------------
+-- inputs:  ?, ?, ?, I
+-- outputs: B, I, ?, ?
+[3] := 9
+[3] := F && T
+[3] := 40 + -40
 [2] := [3]
-[1] := [3] < [3]
-[3] := [1] && F
-[0] := 28
+[1] := -33 + 4
+[0] := F || T
 -------------------------
--- inputs:  I, ?, B, B
--- outputs: B, I, B, ?
-[2] := [3] && T
-[0] := [3]
-[3] := 2 + -6
-[3] := -40
-[3] := [2] || [0]
-[1] := 18
+-- inputs:  ?, B, B, ?
+-- outputs: B, ?, I, I
+[3] := F
+[2] := -18
+[1] := 19 * [2]
+[3] := 7 == 26
+[3] := [2]
+[0] := T
 -------------------------
--- inputs:  I, I, I, ?
--- outputs: ?, I, ?, ?
-[3] := [2] == 23
-[1] := 21
+-- inputs:  B, I, I, B
+-- outputs: B, ?, I, B
+[3] := F
+[1] := [2] < 16
+[3] := T
+[1] := ![3]
+[1] := [2] == [2]
+[3] := !T
 -------------------------
--- inputs:  I, I, ?, I
--- outputs: ?, I, ?, I
+-- inputs:  B, ?, B, ?
+-- outputs: B, ?, B, ?
+[3] := -26 == -38
 [3] := [3]
-[0] := F
-[3] := -4 < [3]
-[2] := [1] * 9
-[3] := -37 * 37
--------------------------
--- inputs:  B, ?, B, I
--- outputs: ?, B, ?, I
-[2] := [0] && F
-[1] := ![2]
-[0] := 2
-[3] := -20
-[2] := [2]
+[2] := 24 * 8
+[3] := F || [0]
+[2] := [2] < -15
+[1] := -31 * 18
 -------------------------
--- inputs:  I, I, I, I
--- outputs: ?, ?, ?, ?
+-- inputs:  I, ?, I, I
+-- outputs: ?, I, ?, ?
+[3] := 6 + -8
+[3] := [3] + [2]
+[3] := F
+[2] := F
+[3] := [3]
+[1] := [0]
diff --git a/examples/pil-dyn/tests/gens/outs-given/expected b/examples/pil-dyn/tests/gens/outs-given/expected
index 4d115ba97..d502ed2c2 100644
--- a/examples/pil-dyn/tests/gens/outs-given/expected
+++ b/examples/pil-dyn/tests/gens/outs-given/expected
@@ -2,74 +2,81 @@
 Now compiling the executable: test
 Output register state is given
 -------------------------
--- inputs: ?, B, ?, B
-[0] := 4
+-- inputs: ?, B, ?, I
+[0] := -33
 [3] := !T
 [3] := -26
 [3] := -2
 [2] := T
 -------------------------
--- inputs: B, B, ?, B
-[3] := -24
-[3] := T
-[3] := -6 == 35
-[2] := T
-[3] := -35 * -21
-[0] := [3]
--------------------------
--- inputs: ?, ?, I, ?
-[3] := 11 == [2]
-[2] := -17
-[0] := -23 + 39
-[2] := T && F
-[1] := ![3]
-[3] := -16 * [0]
--------------------------
--- inputs: ?, ?, B, I
-[3] := [3] < [3]
-[3] := 20 * -3
-[1] := !F
-[3] := 12
-[3] := 20 + [3]
-[0] := -19
+-- inputs: ?, ?, B, B
+[2] := 13
+[3] := F
+[2] := 38 == [2]
+[1] := F && T
+[3] := -21 + 28
+[0] := [3] + [3]
 -------------------------
--- inputs: I, ?, ?, I
-[3] := -18 < 18
-[3] := [3]
+-- inputs: B, I, I, B
+[3] := [2]
+[3] := [0] == T
 [3] := [3]
-[3] := -33 + 4
-[1] := [3] * -17
+[2] := [2] < [2]
+[0] := -8
+[3] := -16 * [1]
+-------------------------
+-- inputs: B, I, I, B
+[3] := [1] == -28
+[3] := [2]
+[1] := [0] && F
+[3] := -30 + 28
+[0] := 20 + [3]
 [2] := T
 -------------------------
--- inputs: I, B, B, I
+-- inputs: ?, ?, I, I
+[3] := [3] * 20
+[3] := F && T
+[2] := [3] || [3]
+[3] := 18
+[1] := -33 + 4
+[0] := [3] * -17
 -------------------------
--- inputs: I, B, B, ?
-[2] := -39
-[3] := -18
-[3] := T && [1]
-[1] := 7 + 26
-[2] := [3]
-[3] := [1] + -1
+-- inputs: ?, B, B, ?
+[3] := F
+[2] := -18
+[1] := 19 * [2]
+[2] := 7 == 26
+[3] := 27 * [1]
+[0] := [3]
 -------------------------
--- inputs: B, I, ?, I
-[2] := T
-[3] := ![2]
-[3] := [1] == -21
-[1] := [1]
-[3] := -34
+-- inputs: B, I, I, B
+[3] := F
+[1] := T
+[3] := [0]
+[3] := [2]
+[2] := F
 [0] := -18
 -------------------------
--- inputs: ?, ?, B, I
-[0] := -20
+-- inputs: I, ?, ?, ?
+[0] := -28
+[2] := 27 + -38
+[1] := 13 + [2]
 [1] := !T
-[2] := F
-[3] := [2]
-[0] := [0] + [0]
-[3] := 10
+[2] := [1]
+[3] := [0] * [0]
 -------------------------
--- inputs: B, I, B, B
-[2] := [3] && T
-[3] := [1]
-[0] := [1]
+-- inputs: B, ?, ?, I
+[2] := [3] < [3]
+[1] := -37 + [3]
 [1] := [2]
-[2] := [1] || T
+[1] := [2]
+[2] := [2]
+[0] := 17
+-------------------------
+-- inputs: B, ?, I, ?
+[3] := 1 * 7
+[0] := 31
+[0] := T && F
+[2] := ![0]
+[1] := -15
+[0] := [1] + 37
diff --git a/examples/pil-fun/src/Language/PilFun.idr b/examples/pil-fun/src/Language/PilFun.idr
index 140bdedf9..d63cf3967 100644
--- a/examples/pil-fun/src/Language/PilFun.idr
+++ b/examples/pil-fun/src/Language/PilFun.idr
@@ -2,11 +2,15 @@ module Language.PilFun
 
 import public Data.Fuel
 import public Data.Nat
+import public Data.SnocList
+import public Data.SnocList.Quantifiers
 
 import Decidable.Equality
 
 import Test.DepTyCheck.Gen
 
+%default total
+
 -- Types of this primitive imperative language
 public export
 data Ty = Int' | Bool'
@@ -23,19 +27,6 @@ data Literal : Ty -> Type where
   I : Nat  -> Literal Int'
   B : Bool -> Literal Bool'
 
-public export
-data MaybeTy = Nothing | Just Ty
-
-export
-Injective PilFun.Just where injective Refl = Refl
-
-export
-DecEq MaybeTy where
-  decEq Nothing Nothing = Yes Refl
-  decEq (Just t) (Just t') = decEqCong (decEq t t')
-  decEq Nothing (Just _) = No $ \case Refl impossible
-  decEq (Just _) Nothing = No $ \case Refl impossible
-
 public export
 data Mut = Mutable | Immutable
 
@@ -46,96 +37,41 @@ DecEq Mut where
   decEq Mutable   Immutable = No $ \case Refl impossible
   decEq Immutable Mutable   = No $ \case Refl impossible
 
-namespace SnocListTy
-
-  public export
-  data SnocListTy : Type where
-    Lin  : SnocListTy
-    (:<) : SnocListTy -> Ty -> SnocListTy
-
-  public export
-  snocListTyToList : SnocListTy -> List Ty
-  snocListTyToList Lin = []
-  snocListTyToList (xs :< x) = (snocListTyToList xs) ++ [x]
-
-  public export
-  length : SnocListTy -> Nat
-  length Lin = Z
-  length (sx :< _) = S $ length sx
-
-  public export %inline
-  (.length) : SnocListTy -> Nat
-  (.length) = length
-
-  export
-  Biinjective SnocListTy.(:<) where
-    biinjective Refl = (Refl, Refl)
-
-  export
-  DecEq SnocListTy where
-    decEq [<] [<] = Yes Refl
-    decEq (sx :< x) (sx' :< x') = decEqCong2 (decEq sx sx') (decEq x x')
-    decEq [<] (_:<_) = No $ \case Refl impossible
-    decEq (_:<_) [<] = No $ \case Refl impossible
-
 namespace SnocListTyMut
 
   public export
-  data SnocListTyMut : Type where
-    Lin  : SnocListTyMut
-    (:<) : SnocListTyMut -> Ty -> Mut -> SnocListTyMut
+  data IndexIn : SnocList t -> Type where
+    Here  : IndexIn $ (:<) sx x
+    There : IndexIn sx -> IndexIn $ (:<) sx x
 
   public export
-  data IndexIn : SnocListTyMut -> Type where
-    Here  : IndexIn $ (:<) sx x mut
-    There : IndexIn sx -> IndexIn $ (:<) sx x mut
-
-  public export
-  index : (sx : SnocListTyMut) -> IndexIn sx -> (Ty, Mut)
-  index ((:<) _  x m) Here      = (x, m)
-  index ((:<) sx _ _) (There i) = index sx i
-
-  public export
-  length : SnocListTyMut -> Nat
-  length Lin = Z
-  length ((:<) sx _ _) = S $ length sx
+  index : (sx : SnocList t) -> IndexIn sx -> t
+  index ((:<) _ x) Here      = x
+  index ((:<) sx _) (There i) = index sx i
 
   public export %inline
-  (.length) : SnocListTyMut -> Nat
+  (.length) : SnocList _ -> Nat
   (.length) = length
 
-  export
-  DecEq SnocListTyMut where
-    decEq [<] [<] = Yes Refl
-    decEq ((:<) sx x m) ((:<) sx' x' m') with (decEq sx sx')
-      _                                   | No nsx = No $ \case Refl => nsx Refl
-      decEq ((:<) sx x m) ((:<) sx x' m') | Yes Refl with (decEq x x')
-        _                                             | No nx = No $ \case Refl => nx Refl
-        decEq ((:<) sx x m) ((:<) sx x m') | Yes Refl | Yes Refl with (decEq m m')
-          _                                                       | No mx = No $ \case Refl => mx Refl
-          decEq ((:<) sx x m) ((:<) sx x m) | Yes Refl | Yes Refl | Yes Refl = Yes Refl
-    decEq [<] ((:<) _ _ _) = No $ \case Refl impossible
-    decEq ((:<) _ _ _) [<] = No $ \case Refl impossible
-
   public export
-  data AtIndex : {sx : SnocListTyMut} -> (idx : IndexIn sx) -> Ty -> Mut -> Type where
+  data AtIndex : {sx : SnocList t} -> (idx : IndexIn sx) -> t -> Type where
     [search sx idx]
-    Here'  : AtIndex {sx = (:<) sx ty mut} Here ty mut
-    There' : AtIndex {sx} i ty mut -> AtIndex {sx = (:<) sx x m} (There i) ty mut
+    Here'  : AtIndex {sx = (:<) sx tm} Here tm
+    There' : AtIndex {sx} i rm -> AtIndex {sx = (:<) sx x} (There i) rm
 
   ||| Add a bunch of immutable variables
   public export
-  (++) : SnocListTyMut -> SnocListTy -> SnocListTyMut
+  (++) : SnocList (Ty, Mut) -> SnocList Ty -> SnocList (Ty, Mut)
   (++) sx Lin       = sx
-  (++) sx (sy :< y) = (:<) (sx ++ sy) y Immutable
+  (++) sx (sy :< y) = (:<) (sx ++ sy) (y, Immutable)
 
 export infix 1 ==>
 
 public export
 record FunSig where
   constructor (==>)
-  From : SnocListTy
-  To   : MaybeTy
+  From : SnocList Ty
+  To   : Maybe Ty
 
 export
 Biinjective (==>) where
@@ -145,56 +81,25 @@ export
 DecEq FunSig where
   decEq (f ==> t) (f' ==> t') = decEqCong2 (decEq f f') (decEq t t')
 
-namespace SnocListFunSig
-
-  public export
-  data SnocListFunSig : Type where
-    Lin  : SnocListFunSig
-    (:<) : SnocListFunSig -> FunSig -> SnocListFunSig
-
-  public export
-  data IndexIn : SnocListFunSig -> Type where
-    Here  : IndexIn $ sx :< x
-    There : IndexIn sx -> IndexIn $ sx :< x
-
-  public export
-  index : (sx : SnocListFunSig) -> IndexIn sx -> FunSig
-  index (_ :<x) Here      = x
-  index (sx:<_) (There i) = index sx i
-
-  public export
-  length : SnocListFunSig -> Nat
-  length Lin = Z
-  length (sx :< _) = S $ length sx
-
-  public export %inline
-  (.length) : SnocListFunSig -> Nat
-  (.length) = length
-
-  public export
-  data AtIndex : {sx : SnocListFunSig} -> (idx : IndexIn sx) -> FunSig -> Type where
-    [search sx idx]
-    Here'  : AtIndex {sx = sx :< sig} Here sig
-    There' : AtIndex {sx} i sig -> AtIndex {sx = sx :< x} (There i) sig
-
 public export
 Vars : Type
-Vars = SnocListTyMut
+Vars = SnocList (Ty, Mut)
 
 public export
 Funs : Type
-Funs = SnocListFunSig
+Funs = SnocList FunSig
 
 public export
-data ExprsSnocList : Funs -> Vars -> SnocListTy -> Type
+data ExprsSnocList : Funs -> Vars -> SnocList Ty -> Type
 
 public export
 data Expr : Funs -> Vars -> Ty -> Type where
 
   C : (x : Literal ty) -> Expr funs vars ty
 
-  V : (n : IndexIn vars) ->
-      AtIndex n ty mut =>
+  V : {mut : Mut} ->
+      (n : IndexIn vars) ->
+      AtIndex n (ty, mut) =>
       Expr funs vars ty
 
   F : (n : IndexIn funs) ->
@@ -204,7 +109,7 @@ data Expr : Funs -> Vars -> Ty -> Type where
       ExprsSnocList funs vars from ->
       Expr funs vars to
 
-data ExprsSnocList : Funs -> Vars -> SnocListTy -> Type where
+data ExprsSnocList : Funs -> Vars -> SnocList Ty -> Type where
   Lin  : ExprsSnocList funs vars [<]
   (:<) : ExprsSnocList funs vars sx -> Expr funs vars ty -> ExprsSnocList funs vars (sx :< ty)
 
@@ -213,12 +118,12 @@ export infix 2 #=
 public export
 data Stmts : (funs : Funs) ->
              (vars : Vars) ->
-             (retTy : MaybeTy) -> Type where
+             (retTy : Maybe Ty) -> Type where
 
   NewV : (ty : Ty) ->
          (mut : Mut) ->
          (initial : Expr funs vars ty) ->
-         (cont : Stmts funs ((:<) vars ty mut) retTy) ->
+         (cont : Stmts funs ((:<) vars (ty, mut)) retTy) ->
          Stmts funs vars retTy
 
   NewF : (sig : FunSig) ->
@@ -227,7 +132,7 @@ data Stmts : (funs : Funs) ->
          Stmts funs vars retTy
 
   (#=) : (n : IndexIn vars) ->
-         AtIndex n ty Mutable =>
+         AtIndex n (ty, Mutable) =>
          (v : Expr funs vars ty) ->
          (cont : Stmts funs vars retTy) ->
          Stmts funs vars retTy
@@ -249,4 +154,4 @@ data Stmts : (funs : Funs) ->
   Nop  : Stmts funs vars Nothing
 
 export
-genStmts : Fuel -> (funs : Funs) -> (vars : Vars) -> (retTy : MaybeTy) -> Gen MaybeEmpty $ Stmts funs vars retTy
+genStmts : Fuel -> (funs : Funs) -> (vars : Vars) -> (retTy : Maybe Ty) -> Gen MaybeEmpty $ Stmts funs vars retTy
diff --git a/examples/pil-fun/src/Language/PilFun/DSL.idr b/examples/pil-fun/src/Language/PilFun/DSL.idr
index 9d0a388ab..e2e91b40f 100644
--- a/examples/pil-fun/src/Language/PilFun/DSL.idr
+++ b/examples/pil-fun/src/Language/PilFun/DSL.idr
@@ -28,24 +28,24 @@ namespace Utils
 namespace SnocListTyMut.IndexIn
 
   public export
-  natToIndexIn : (n : Nat) -> {sx : SnocListTyMut} -> n `LT` length sx => IndexIn sx
-  natToIndexIn 0     {sx=(:<) sx x m}              = Here
-  natToIndexIn (S k) {sx=(:<) sx x m} @{LTESucc l} = There $ natToIndexIn k
+  natToIndexIn : (n : Nat) -> {sx : SnocList (Ty, Mut)} -> n `LT` length sx => IndexIn sx
+  natToIndexIn 0     {sx=(:<) sx (x, m)}              = Here
+  natToIndexIn (S k) {sx=(:<) sx (x, m)} @{LTESucc l} = There $ natToIndexIn k
 
   public export
-  fromInteger : {sx : SnocListTyMut} -> (n : Integer) -> (cast n `LT` length sx) => {- (x >= the Integer 0 = True) =>-} IndexIn sx
+  fromInteger : {sx : SnocList (Ty, Mut)} -> (n : Integer) -> (cast n `LT` length sx) => {- (x >= the Integer 0 = True) =>-} IndexIn sx
   fromInteger n with (cast {to=Nat} n)
     _ | n' = natToIndexIn (length sx `minus` S n') @{reverseLTMinus}
 
 namespace SnocListFunSig.IndexIn
 
   public export
-  natToIndexIn : (n : Nat) -> {sx : SnocListFunSig} -> n `LT` length sx => IndexIn sx
+  natToIndexIn : (n : Nat) -> {sx : SnocList FunSig} -> n `LT` length sx => IndexIn sx
   natToIndexIn 0     {sx=sx:<x}              = Here
   natToIndexIn (S k) {sx=sx:<x} @{LTESucc l} = There $ natToIndexIn k
 
   public export
-  fromInteger : {sx : SnocListFunSig} -> (n : Integer) -> (cast n `LT` length sx) => {- (x >= the Integer 0 = True) =>-} IndexIn sx
+  fromInteger : {sx : SnocList FunSig} -> (n : Integer) -> (cast n `LT` length sx) => {- (x >= the Integer 0 = True) =>-} IndexIn sx
   fromInteger n with (cast {to=Nat} n)
     _ | n' = natToIndexIn (length sx `minus` S n') @{reverseLTMinus}
 
diff --git a/examples/pil-fun/src/Language/PilFun/Derived.idr b/examples/pil-fun/src/Language/PilFun/Derived.idr
index 10bc836ba..96add9a89 100644
--- a/examples/pil-fun/src/Language/PilFun/Derived.idr
+++ b/examples/pil-fun/src/Language/PilFun/Derived.idr
@@ -8,5 +8,6 @@ import Deriving.DepTyCheck.Gen
 
 %logging "deptycheck.derive" 5
 %logging "deptycheck.derive.least-effort" 7
+%logging "deptycheck.util" 20
 
 Language.PilFun.genStmts = deriveGen
diff --git a/examples/pil-fun/src/Language/PilFun/Pretty.idr b/examples/pil-fun/src/Language/PilFun/Pretty.idr
index 064825b02..4042366cd 100644
--- a/examples/pil-fun/src/Language/PilFun/Pretty.idr
+++ b/examples/pil-fun/src/Language/PilFun/Pretty.idr
@@ -26,11 +26,11 @@ data SupportedLanguage = Scala3
 public export
 data ScalaCondition : FunSig -> (isInfix : Bool) -> (isPure : Bool) -> Type where
   IsNotInfix : ScalaCondition funSig False b
-  MoreThanOneArg : So (funSig.From.length >= 1) -> ScalaCondition funSig isInfix b
+  MoreThanOneArg : So ((length funSig.From) >= 1) -> ScalaCondition funSig isInfix b
 
 public export
 data IdrisCondition : FunSig -> (isInfix : Bool) -> (isPure : Bool) -> Type where
-  IsInfix : (a : Ty ** b : Ty ** to : MaybeTy ** funSig === ([<a, b] ==> to)) -> (isPure : Bool) -> IdrisCondition funSig True isPure
+  IsInfix : (a : Ty ** b : Ty ** to : Maybe Ty ** funSig === ([<a, b] ==> to)) -> (isPure : Bool) -> IdrisCondition funSig True isPure
   NotInfix : (isPure : Bool) -> IdrisCondition funSig False isPure
 
 public export
@@ -57,13 +57,13 @@ data UniqNames : (l : SupportedLanguage) -> (funs : Funs) -> (vars : Vars) -> Ty
             {default False isInfix : Bool} -> {default False isPure : Bool} ->
             (languageCondition : LanguageToCondition l fun isInfix isPure) =>
             UniqNames l (funs:<fun) vars
-  NewVar  : (ss : UniqNames l funs vars) => (s : String) -> (0 _ : NameIsNew l funs vars ss s) => UniqNames l funs ((:<) vars var mut)
+  NewVar  : (ss : UniqNames l funs vars) => (s : String) -> (0 _ : NameIsNew l funs vars ss s) => UniqNames l funs ((:<) vars (var, mut))
 
 data NameIsNew : (l : SupportedLanguage) -> (funs : Funs) -> (vars : Vars) -> UniqNames l funs vars -> String -> Type where
   E : NameIsNew l [<] [<] Empty x
   J : (0 _ : So $ x /= s) -> NameIsNew l funs vars ss x -> NameIsNew l funs vars (JustNew @{ss} s @{sub}) x
   F : (0 _ : So $ x /= s) -> NameIsNew l funs vars ss x -> NameIsNew l (funs:<fun) vars (NewFun @{ss} {isInfix} {isPure} s @{sub} @{infixCond}) x
-  V : (0 _ : So $ x /= s) -> NameIsNew l funs vars ss x -> NameIsNew l funs ((:<) vars var mut) (NewVar @{ss} s @{sub}) x
+  V : (0 _ : So $ x /= s) -> NameIsNew l funs vars ss x -> NameIsNew l funs ((:<) vars (var, mut)) (NewVar @{ss} s @{sub}) x
 
 public export
 interface NamesRestrictions where
@@ -116,7 +116,7 @@ newVars : NamesRestrictions =>
           Fuel ->
           (newNames : Gen0 String) ->
           (extraVars : _) -> UniqNames l funs vars ->
-          Gen0 (UniqNames l funs (vars ++ extraVars), Vect extraVars.length (String, Ty))
+          Gen0 (UniqNames l funs (SnocListTyMut.(++) vars extraVars), Vect (SnocList.length extraVars) (String, Ty))
 newVars _  _ [<] names = pure (names, [])
 newVars fl newNames (vs:<v) names = do
   (names', vts) <- newVars fl newNames vs names
diff --git a/examples/pil-fun/src/Language/PilFun/Pretty/Idris2.idr b/examples/pil-fun/src/Language/PilFun/Pretty/Idris2.idr
index 4f3f90295..c9e1e6672 100644
--- a/examples/pil-fun/src/Language/PilFun/Pretty/Idris2.idr
+++ b/examples/pil-fun/src/Language/PilFun/Pretty/Idris2.idr
@@ -38,7 +38,7 @@ printTy : Ty -> Doc opts
 printTy Int' = "Int"
 printTy Bool' = "Bool"
 
-printMaybeTy : MaybeTy -> Doc opts
+printMaybeTy : Maybe Ty -> Doc opts
 printMaybeTy Nothing   = "()"
 printMaybeTy $ Just ty = printTy ty
 
@@ -58,8 +58,8 @@ data ArgStruct : LayoutOpts -> Type where
   ManyArgs : {opts : _} -> List (Doc opts) -> ArgStruct opts
   NoArgs : {opts : _} -> ArgStruct opts
 
-getArgs : {from' : SnocListTy} ->
-          {to' : MaybeTy} ->
+getArgs : {from' : SnocList Ty} ->
+          {to' : Maybe Ty} ->
           (argFs : Funs ** argVs : Vars ** argNms : UniqNames Idris2 argFs argVs ** ExprsSnocList argFs argVs from') ->
           {fs : Funs} ->
           {vs : Vars} ->
@@ -166,7 +166,7 @@ printStmts fl $ NewF ([< a, b ] ==> maybeRet) body cont = do
   (nm ** _) <- genNewName fl nameGen _ _ names
   rest <- printStmts @{NewFun nm {isInfix} @{names}} fl cont
   let infixAwareName : Doc opts = if isInfix then "(" <+> line nm <+> ")" else line nm
-  let processedInputTypes : Doc opts = hsep $ (snocListTyToList [< a, b ]) <&> (\ty => printTy ty <++> "->")
+  let processedInputTypes : Doc opts = hsep $ (toList [< a, b ]) <&> (\ty => printTy ty <++> "->")
   let processedOutputType = "IO" <++> printMaybeTy maybeRet
   let idrisTypeSignature = processedInputTypes <++> processedOutputType
   (namesInside, funArgs) <- newVars fl alphaNames [< a, b ] (JustNew @{names} nm)
@@ -183,7 +183,7 @@ printStmts fl $ NewF (typesFrom ==> maybeRet) body cont = do
   (nm ** _) <- genNewName fl alphaNames _ _ names
   rest <- printStmts @{NewFun nm {isInfix} @{names}} fl cont
   let funName = line nm
-  let processedInputTypes : Doc opts = hsep $ (snocListTyToList typesFrom) <&> (\ty => printTy ty <++> "->")
+  let processedInputTypes : Doc opts = hsep $ (toList typesFrom) <&> (\ty => printTy ty <++> "->")
   let processedOutputType = "IO" <++> printMaybeTy maybeRet
   let idrisTypeSignature = processedInputTypes <++> processedOutputType
   (namesInside, funArgs) <- newVars fl alphaNames _ (JustNew @{names} nm)
diff --git a/examples/pil-fun/src/Language/PilFun/Pretty/Scala3.idr b/examples/pil-fun/src/Language/PilFun/Pretty/Scala3.idr
index d0ccb8afa..0e3d78549 100644
--- a/examples/pil-fun/src/Language/PilFun/Pretty/Scala3.idr
+++ b/examples/pil-fun/src/Language/PilFun/Pretty/Scala3.idr
@@ -21,7 +21,7 @@ printTy : Ty -> Doc opts
 printTy Int'  = "Int"
 printTy Bool' = "Boolean"
 
-printMaybeTy : MaybeTy -> Doc opts
+printMaybeTy : Maybe Ty -> Doc opts
 printMaybeTy Nothing   = "Unit"
 printMaybeTy $ Just ty = printTy ty
 
diff --git a/examples/pil-fun/tests/gens/scala3/expected b/examples/pil-fun/tests/gens/scala3/expected
index 33d15c8a0..307739ab7 100644
--- a/examples/pil-fun/tests/gens/scala3/expected
+++ b/examples/pil-fun/tests/gens/scala3/expected
@@ -1,587 +1,159 @@
 -------------------
 
+val ynynxspcyx: Int =
+  (((((0.*(6)) * (-(2))) * (5.*(6))).*(6 * (-(0)))) * ((((2.*(5)).*(2 * 0)) * (6 * 2)) * 2)) * (-(((5 * 4).+(5.*(0 * 0))).*(4.*(2.*(5)))))
 
 @main
-def vdpxa(): Unit = {
-  if (1.*(-(3 * (2 * 2)))).==((-(3)) * ((0.*(3)).*(0))) then {
-    if 4 == (2.*((((2 * 6).*(0)).*(4 * (5 * 0))).*(((3.*(2)) * (4 * 0)).*(2.*(4.*(0)))))) then {
-      if ((5.==((6 * (-(1))).*(-(2)))) || (((0 * 6) * (2 * 0)) == (-(-(3))))) || (((4 + (-(1.*(0)))).*((4 * 4) * ((1 * 4).*(4.*(3))))) == (3 * 5)) then
-        {}
-      else
-        Console.println(((-(2.*(6))) * (((4.*(4)).+((2 * 0).*(4.*(6)))).*((-(0.*(2))) * 1))) * (((1 * (3.*(4 * 2))).*((3.*(5)).*(4))).*(4 + (-(0)))))
-        Console.println(0)
-        if (!((false.&&((true.&&(true)) && (!(true)))) && (2 == (5 * (-(5)))))) && true then {
-          
-        } else {
-          
-        }
-        
-      
-    } else {
-      Console.println((-(3)) * (-((6 * 2) * (((3.*(6)).*(0 * 1)) * 5))))
-      val cu = () => {  } 
-      val p = (-(5)).==(6)
+def jdrbitq(): Unit = {
+  if (-((ynynxspcyx * (-(-(1)))).+(ynynxspcyx.+((2 * 0) * ynynxspcyx)))) <= ((-(-(3 * 5))).*((-(ynynxspcyx.*(ynynxspcyx * ynynxspcyx))) * (4 + ((-(ynynxspcyx)).*(-(ynynxspcyx)))))) then {
+    if ynynxspcyx.==((((ynynxspcyx.+(ynynxspcyx.*(5))) * (ynynxspcyx.*(5 + 0))) * 0).*(ynynxspcyx)) then
+      {}
+    else
+      var te = 3 < ((2 * ((ynynxspcyx.+(ynynxspcyx)) * 1)).+(((5.*(ynynxspcyx)) + (ynynxspcyx.+(ynynxspcyx))) + ((ynynxspcyx.*(6)).*(ynynxspcyx))))
+      val ewa = (ynynxspcyx * ((ynynxspcyx * (2.+(ynynxspcyx))) * ynynxspcyx)) * (ynynxspcyx * (ynynxspcyx + (2 * (-(ynynxspcyx + ynynxspcyx)))))
+      val flvpa = true
       
-    }
-    def qsrdonvvh(): Int = {
-      val r = (ml: Int, giiumorq: Int, yrgkhcqkn: Int, b: Int, mjejiv: Int) =>
-        if ((-(0.*((yrgkhcqkn * mjejiv) * (6.*(mjejiv))))) == (-(ml))).&&((!(((0.*(2)) == 3) && ((2.*(giiumorq)).==(0)))) && (!(((1 * 1).*(5.*(6))).==(5)))) then
-          {}
-        else
-          if (((5.*(5)) * 6) * (-(((-(giiumorq)) * 6).*(2)))) == 3 then {
-            
-          }
-          
-        extension (dxx: Boolean) def m(lrutpowzm: Boolean, lojlnrcx: Int) = {  } 
-        !(((((ml * 1).*(b)) * (-(yrgkhcqkn))) * (ml.+(2.*(4)))) < ((giiumorq.+(-(6))).*(5 * 5))) 
-      if r
-           ( ((-(5 + 4)).*((0 * 5) + 0)) * (-(1 * ((-(3)) * (3.+(2)))))
-           , ((((0.*(6)) * (6.*(5))).*(3 * 6)) * ((3.*(6)) + 0)) * (0 * (2 * (-(1))))
-           , 3 * (((0.*(3)) * (-(-(3)))) + ((0 * 0) * (0.*(5.*(6)))))
-           , ((6.*((0.+(1)) * 2)).*(5)).+(6)
-           , (-(((5.*(5)) * (3.*(4))) * ((4 * 6) * (5 * 1)))) * (-(3))
-           ) then
-        if r
-             ( 4.*(-(((4 * 2) * (1 + 0)).*(6)))
-             , -(((-(3.*(3))).*(5 * (6 * 3))) * (1 * 0))
-             , 1.*((5.*((3.*(6)).*(4))) + (((1 * 6) * (-(2))).*((6.*(5)).+(4))))
-             , (-(((1 * 5).*(2 * 0)).*((4 * 2).*(4)))).*(-((0 * (2.*(6))) * (4 * 1)))
-             , 3.*(((3 + 0).*(3)) * ((1.+(3)) * ((6 * 1).*(1))))
-             ) then
-          {}
-        
-      else
-        {}
-      if true then {
+    var mmopked: Boolean = false
+    if mmopked then
+      if ((ynynxspcyx.*(6)).*(-(3))).==(-(1)) then {
         
       } else {
         
       }
-      -(2.+(3 * (((1 * 3) * 5).+(5))))
-    } 
-    val oeywpe = (zfz: Boolean, jmvrzlzqin: Int, irp: Int, u: Boolean, defc: Int) => {
-      if 1 == qsrdonvvh() then
-        if irp.==(irp) then {
-          
-        }
-        
-      else
-        Console.println(-((((6.*(qsrdonvvh())) * (qsrdonvvh() * (-(1)))).*(0 * 1)) * (-(qsrdonvvh() * 2))))
-        
-      jmvrzlzqin * ((-(qsrdonvvh())).*((3 * (4 * jmvrzlzqin)) * 0))
-    } 
-    if false.||(((!(oeywpe(true, 6, 4, true, 5).<(-(5)))) && true).&&((2 == 6).&&((false && true) && (false && false)))) then
-      val rr = () =>
-        {} 
       
     else
-      val cgsaa: Int =
-        oeywpe
-          ( !
-              ( (oeywpe
-                   ( 3 == 4
-                   , 0
-                   , -(0)
-                   , false.&&(false)
-                   , 2
-                   ).==(oeywpe(true, 1, oeywpe(false, 4, 0, true, 1), false || true, 6))) || (!(oeywpe(true, 5, 3, true, 0).==(3)))
-              )
-          , qsrdonvvh()
-          , oeywpe
-              ( oeywpe
-                  ( false
-                  , oeywpe(false, oeywpe(false, 4, 6, true, 6), oeywpe(false, 1, 0, true, 1), true && true, -(0))
-                  , oeywpe(true, 5, oeywpe(true, 4, 2, false, 4), true.&&(false), -(5))
-                  , true && (3 == 6)
-                  , oeywpe(true, 4, 6, 5 == 5, -(4))
-                  ).==(5)
-              , oeywpe
-                  ( 6.==(qsrdonvvh())
-                  , oeywpe
-                      ( 6.==(-(1))
-                      , oeywpe(false.&&(false), -(5), 1, 5.==(2), 4 * 4)
-                      , 6
-                      , 4.==(oeywpe(false, 0, 6, true, 5))
-                      , oeywpe(false, oeywpe(false, 6, 4, true, 2), oeywpe(true, 5, 5, true, 0), true, -(5))
-                      )
-                  , qsrdonvvh()
-                  , (4 * 1) == 6
-                  , 5
-                  )
-              , oeywpe(((false.&&(true)) || (4.<=(1))) && false, 1, 0, (!(6 == 6)).&&(true && false), 0)
-              , true
-              , -
-                  ( oeywpe
-                      ( qsrdonvvh().<=(oeywpe(false, 2, 3, false, 1))
-                      , 0
-                      , oeywpe(false && true, -(1), 0, 0.==(1), 3)
-                      , oeywpe(true, 2, 5, true, 5).==(oeywpe(true, 6, 3, false, 0))
-                      , 6
-                      )
-                  )
-              )
-          , oeywpe
-              ( true && (true && (!(true)))
-              , -(oeywpe(true, qsrdonvvh(), 3, true, 3 * 5))
-              , oeywpe(!(true), 5, oeywpe(true, 1 * 2, -(1), true, 2), false, 4)
-              , true
-              , oeywpe(4.==(4), 1, 4, true && false, 1).*(6)
-              ) < 3
-          , oeywpe
-              ( true
-              , 0
-              , oeywpe
-                  ( !(false)
-                  , oeywpe(3 == 1, oeywpe(false && true, 0, qsrdonvvh(), true, qsrdonvvh()), oeywpe(4 < 1, 1, 6, false, 2), !(5.==(4)), 1)
-                  , qsrdonvvh()
-                  , 6 == oeywpe(false, 1, 1.*(0), 1 == 0, oeywpe(true, 5, 4, false, 4))
-                  , oeywpe
-                      ( false
-                      , oeywpe(true.&&(false), oeywpe(true, 4, 4, true, 0), 3, true, 2)
-                      , 5
-                      , true
-                      , oeywpe(true, oeywpe(true, 0, 2, false, 1), 5, !(true), 3)
-                      )
-                  )
-              , !(oeywpe(false.||(true), 3, 0, false, oeywpe(false, 3, 5, false, 4)).<(qsrdonvvh()))
-              , 5
-              )
-          )
-      
-    var kqeyphmd: Boolean = false
-    
-  } else {
-    val ojbcnbh = 5
-    val fyjre: Boolean = ((ojbcnbh * ((ojbcnbh.*(1)).*(ojbcnbh))).==(ojbcnbh)).&&(((-(6)) * (1.*((5.*(1)) * 1))) == ojbcnbh)
-    var tuonwnoerf: Int = -((((4.*(ojbcnbh)) * ojbcnbh) + ((ojbcnbh * (-(2))).*(ojbcnbh))) + 1)
-    if ((3 + 5).*(ojbcnbh.*(2))).==((-(ojbcnbh)).*(2)) then
-      Console.println
-        ((((4.*(tuonwnoerf + 2)).*(((4 * ojbcnbh).*(tuonwnoerf)).+(3))) * ((3 * ojbcnbh) * ((5.*(ojbcnbh * 6)).*((1 * ojbcnbh) * 6)))) + ((ojbcnbh.*(5)).*((ojbcnbh.*((ojbcnbh * ojbcnbh).*(ojbcnbh * 3))).*((-(-(ojbcnbh))).*(ojbcnbh)))))
+      Console.println((ynynxspcyx + ynynxspcyx) + ynynxspcyx)
       
+    if true then
+      {}
     else
       {}
-    tuonwnoerf = ojbcnbh
-    
-  }
-  Console.println(0 * (((3.*((3 * 2).*(2.*(6)))) * ((-(0)) * ((2 * 3) * 0))).*(((1 * 1) * (2 + (1.+(3)))) * 3)))
-  var h =
-    ((((-(5)) * ((-(1)) * 4)) * (((2.*(5)).*(5)).*(5.*(1)))).*(3.*((6 * 1).*(6)))).+((-(((-(1)).*(6)).*((-(2)).*(5)))).*((((2 * 3) * (6.*(1))).*(0.*(5.*(0)))) * 6))
-  extension (yk: Int)
-    def eno(): Unit = {
-      var hdjqmwzjvq =
-        ((2.==((h * (h * yk)).*((3.*(h)) * (-(1))))) && ((((false || true) || true).&&(false)) && (false && (true && (h.==(h)))))).&&(!((0.*(0)) < h))
-      Console.println((((4 * (h.*(2))) * (-(5))) * 5) * (-(0)))
-      
-    } 
-  h = (((((2.*(2)).*(h.*(h))).*(h * 0)) * 4) * 6).*(((((h.*(h)).*(h)).*((3.*(h)).*(5))) * ((h.*(6 * h)).*(h))) * (((-(h)).*(0 * h)) * (((5.*(h)) * 4) * 5)))
-  h = h
-  
-}
--------------------
-
-val vq = 0
-
-@main
-def yarimzgu(): Unit = {
-  if !(!(6 == 0)) then {
-    var jlhmmq: Int = vq
-    extension (ghivn: Boolean)
-      def dypbtyxf(jbsy: Int, c: Boolean) = {
-        jlhmmq = -(((((vq * 5).*(vq)).*(jbsy * (vq.*(vq)))).*((3.*(jlhmmq)) * vq)) * (-(5 * 1)))
-        if false then
-          {}
-        ((((0.*(vq)).*(6 * 6)) * ((0.*(jbsy)).*((vq * 4).*(vq)))) * ((1 * vq) * (-(vq)))).*(-(((vq.*(1.*(vq))) + (jbsy * jlhmmq)) * ((vq * (6 * 3)) * 1)))
-      } 
-    val tylbuarm: Boolean =
-      (true.dypbtyxf( (((6.<(6)).dypbtyxf( vq
-                                         , false
-                                         )) == (false.dypbtyxf( vq
-                                                                    , vq == vq
-                                                                    ))).dypbtyxf( (vq.==(4)).dypbtyxf( false.dypbtyxf( 5
-                                                                                                                              , false
-                                                                                                                              )
-                                                                                                              , true.&&(false)
-                                                                                                              )
-                                                                                         , (!(true)) || false
-                                                                                         )
-                    , jlhmmq.<=(5)
-                    )).<=( (((!(6.==(jlhmmq))) || true) && false).dypbtyxf( jlhmmq
-                                                                                                                                                                                          , true
-                                                                                                                                                                                          )
-                                                                                                                                         )
-    val zurnferod = true && tylbuarm
     
   } else {
-    Console.println((-((4 * (vq.*(1))) * 4)).*(5))
-    if (vq * ((2 * (4 * (vq * vq))).*((5.+(vq)).*(vq)))) == ((((2 * vq) * vq) * (vq * 5)).*((2 * ((vq * 5).*(vq))) * 0)) then {
-      val zd: Int = vq
-      var dxofglgc: Boolean = ((((-(-(vq))) * 2) * ((5.*(vq)).*(0))) * vq) == ((-(-(3 * 5))) * ((-(vq.*(6 * vq))).*(2)))
+    def evc(uwo: Boolean, wmpfqwta: Int, vs: Int, bqzet: Int) =
+      Console.println((((4.*(vs)).*((ynynxspcyx.*(2)).*(ynynxspcyx * 4))).*((-(wmpfqwta)).+(bqzet.*(2.*(0))))) + (wmpfqwta * 3))
+      val heytkxp = (ffjio: Boolean, ltzhf: Int) =>
+        extension (omcmkgbaxl: Boolean)
+          def fblsyj(ieebwc: Boolean, mgb: Boolean, xhbkvw: Int, lrkb: Boolean) = { ((5.*(ltzhf)).*(2.*(0.*(-(0))))) * ltzhf } 
+         
+      val vz = (ouaj: Boolean, nbd: Int, iiycetwe: Boolean, uaurcdniyd: Boolean) => {  } : Unit
+       
+    val lnvcqk: Boolean = ynynxspcyx < (6 * ynynxspcyx)
+    if false then
+      evc
+        ( (((-(ynynxspcyx)).*((ynynxspcyx.+(ynynxspcyx)).+(6))) + 5) <= (-(4))
+        , ((-(((5.+(ynynxspcyx)).*(2 + ynynxspcyx)) * ((4.+(ynynxspcyx)) * 1))) + ynynxspcyx).*((((6 + ynynxspcyx) * ynynxspcyx) * ((ynynxspcyx.*(6)).*(ynynxspcyx))).*(3))
+        , ynynxspcyx
+        , -(2)
+        )
       
-    } else {
-      Console.println(((vq + ((-(vq)).*(vq))).*(vq)) * (-(4 * vq)))
-      if (((true || (2.==(4))) && ((false && (true && true)) && false)) || true).||(false) then {
-        
-      } else {
-        
-      }
+    else
+      var kcqjvbjmdv = (-(ynynxspcyx.+(ynynxspcyx))).*(ynynxspcyx)
       
-    }
-    val akwftikho = 1.<=(vq)
+    var ffz: Int = -((ynynxspcyx * 0).*(ynynxspcyx))
     
   }
-  Console.println(vq)
-  Console.println(6)
-  if false then
-    extension (ajd: Int)
-      def bwvxxxror() =
-        {} 
-    
-  else
-    var nfqt = 3 == ((vq * vq).*(-(vq * ((vq.*(vq)).*(5)))))
-    
   
 }
 -------------------
 
-val vvw = (jnagczqp: Boolean, rsrxh: Boolean, yhlaujkvk: Int) => {
-  val onrgts = (tggthuyw: Int) => {
-    extension (cybn: Boolean)
-      def irrqsabpiv(scdsiwx: Int, emuhuf: Boolean, kbchw: Int, b: Boolean, stkyy: Int) = {
-        Console.println(6.*(5))
-        if rsrxh then
-          {}
-        else
-          extension (uhhvsa: Int) def egzdl(tliob: Int, lo: Boolean, jsj: Int): Unit = { {} } : Unit
-          
-        val suxf = (fpwsxwavb: Int, wgk: Boolean, u: Boolean) => { {} } : Unit
-        yhlaujkvk
+val kki = () => {
+  if ((-(2.*(1))) + (((6 * 0).+(3)).+((2.*(-(1))) + (4 * (5.*(1)))))).<(((0.*(6.*(5))) * 6) * (((-(4)) * (2 * (4.*(3)))).*(2.*(5)))) then {
+    Console.println
+      (((-(1 * ((5 * 2) * 1))).*(((0.*(3)).*(-(3))).*((3 * (2 * 1)) * 5))) * (((-((0.*(2)) + 1)).*(5 * (5.*(3)))).*((3 * ((1 * 4) * (6 * 0))).+(2 * (-(5 * 3))))))
+    Console.println
+      ((((-(3)) * (((-(4)).+(4)) * (2 * (-(1))))) * (((-(2)).+(1 * (2 * 0))) * ((-(3)).*(2)))).*((((-(1)) * 6) * (-(2 * (3 * 4)))).+(-(((4.+(5)) * (5.*(2))) * (0 * 1)))))
+    def hzxxhclil(cblgles: Boolean, aao: Int) = {
+      Console.println((-(4.*(aao))) * (((aao * (aao * aao)) * (((1 * 0) + aao).*(aao))).*(aao)))
+      ((1 + (0.*(aao))) * (-(5))) <= ((aao.*(aao)) * 1)
+    } 
+    
+  } else {
+    if (((6 * (0 * 2)).*(5.*((4.*(1)).*(0)))).*(4 * (6.*((4.*(6)).*(2.*(2)))))) == 2 then
+      def ykazx(qnfijusp: Boolean): Boolean = {
+        val ivqydxyay = (6 * 6) <= (-(-(((-(0)) * 6).*((0.*(0)) + 0))))
+        val wavh = (((((5 * 6).*(5)) * ((3 + 0) * (2.*(0)))) * ((4.*(1)) * (4 * 0))) * 0).*(0)
+        wavh.==(0 + ((4 + wavh).*(wavh)))
       } 
-    if !(true && jnagczqp) then {
-      var y =
-        (-
-           ( true.irrqsabpiv( 1
-                            , (true.irrqsabpiv( true.irrqsabpiv( 5
-                                                               , false
-                                                               , 2
-                                                               , true
-                                                               , 1
-                                                               )
-                                              , rsrxh
-                                              , tggthuyw
-                                              , jnagczqp
-                                              , true.irrqsabpiv( yhlaujkvk
-                                                               , true
-                                                               , 5
-                                                               , jnagczqp
-                                                               , 3
-                                                               )
-                                              )) == (jnagczqp.irrqsabpiv( tggthuyw
-                                                                                                   , false
-                                                                                                   , 2
-                                                                                                   , jnagczqp
-                                                                                                   , -(1)
-                                                                                                   ))
-                            , -
-                                ( (yhlaujkvk.==(yhlaujkvk)).irrqsabpiv( tggthuyw
-                                                                      , false
-                                                                      , -(yhlaujkvk)
-                                                                      , true
-                                                                      , yhlaujkvk
-                                                                      )
-                                )
-                            , (!(jnagczqp)) && jnagczqp
-                            , false.irrqsabpiv( 0
-                                              , jnagczqp || rsrxh
-                                              , -(2)
-                                              , rsrxh
-                                              , jnagczqp.irrqsabpiv( yhlaujkvk * tggthuyw
-                                                                   , jnagczqp
-                                                                   , 5
-                                                                   , true
-                                                                   , true.irrqsabpiv( yhlaujkvk
-                                                                                    , false
-                                                                                    , yhlaujkvk
-                                                                                    , rsrxh
-                                                                                    , tggthuyw
-                                                                                    )
-                                                                   )
-                                              )
-                            )
-           )) == ((!(jnagczqp || rsrxh)).irrqsabpiv( (!(3.==(tggthuyw))).irrqsabpiv( rsrxh.irrqsabpiv( true.irrqsabpiv(5, jnagczqp, yhlaujkvk, jnagczqp, 4)
-                                                                                                                                                                                                       , false
-                                                                                                                                                                                                       , -(tggthuyw)
-                                                                                                                                                                                                       , true.&&(jnagczqp)
-                                                                                                                                                                                                       , (jnagczqp.irrqsabpiv(6, jnagczqp, 5, jnagczqp, 3)) * yhlaujkvk
-                                                                                                                                                                                                       )
-                                                                                                                                                                                     , 6 <= yhlaujkvk
-                                                                                                                                                                                     , yhlaujkvk
-                                                                                                                                                                                     , jnagczqp
-                                                                                                                                                                                     , (-(false.irrqsabpiv(yhlaujkvk, jnagczqp, 1, rsrxh, 1))) * 0
-                                                                                                                                                                                     )
-                                                                                                                                                     , (false.irrqsabpiv(3, false, 6, true, yhlaujkvk * yhlaujkvk)).<(2)
-                                                                                                                                                     , 3
-                                                                                                                                                     , ((2 < yhlaujkvk) && ((6 * 3) == yhlaujkvk)).&&( yhlaujkvk == ((false.irrqsabpiv( yhlaujkvk
-                                                                                                                                                                                                                                      , jnagczqp
-                                                                                                                                                                                                                                      , 4
-                                                                                                                                                                                                                                      , jnagczqp
-                                                                                                                                                                                                                                      , tggthuyw
-                                                                                                                                                                                                                                      )) * yhlaujkvk)
-                                                                                                                                                                                                     )
-                                                                                                                                                     , jnagczqp.irrqsabpiv( (yhlaujkvk.==( jnagczqp.irrqsabpiv( yhlaujkvk
-                                                                                                                                                                                                              , true
-                                                                                                                                                                                                              , yhlaujkvk
-                                                                                                                                                                                                              , false
-                                                                                                                                                                                                              , yhlaujkvk
-                                                                                                                                                                                                              )
-                                                                                                                                                                                         )).irrqsabpiv( tggthuyw
-                                                                                                                                                                                                                                     , false
-                                                                                                                                                                                                                                     , true.irrqsabpiv( false.irrqsabpiv( 5
-                                                                                                                                                                                                                                                                        , jnagczqp
-                                                                                                                                                                                                                                                                        , yhlaujkvk
-                                                                                                                                                                                                                                                                        , jnagczqp
-                                                                                                                                                                                                                                                                        , yhlaujkvk
-                                                                                                                                                                                                                                                                        )
-                                                                                                                                                                                                                                                      , 4.==(yhlaujkvk)
-                                                                                                                                                                                                                                                      , jnagczqp.irrqsabpiv( yhlaujkvk
-                                                                                                                                                                                                                                                                           , false
-                                                                                                                                                                                                                                                                           , 1
-                                                                                                                                                                                                                                                                           , jnagczqp
-                                                                                                                                                                                                                                                                           , yhlaujkvk
-                                                                                                                                                                                                                                                                           )
-                                                                                                                                                                                                                                                      , jnagczqp
-                                                                                                                                                                                                                                                      , 4
-                                                                                                                                                                                                                                                      )
-                                                                                                                                                                                                                                     , rsrxh && (0 == 4)
-                                                                                                                                                                                                                                     , jnagczqp.irrqsabpiv( 0
-                                                                                                                                                                                                                                                          , jnagczqp
-                                                                                                                                                                                                                                                          , 0
-                                                                                                                                                                                                                                                          , rsrxh
-                                                                                                                                                                                                                                                          , -(4)
-                                                                                                                                                                                                                                                          )
-                                                                                                                                                                                                                                     )
-                                                                                                                                                                          , ((rsrxh && true).irrqsabpiv(1, 6.==(0), 3, true && false, 0)).<=(-(1))
-                                                                                                                                                                          , rsrxh.irrqsabpiv( false.irrqsabpiv(yhlaujkvk, yhlaujkvk.<=(yhlaujkvk), yhlaujkvk, false, yhlaujkvk)
-                                                                                                                                                                                            , rsrxh
-                                                                                                                                                                                            , -(true.irrqsabpiv(tggthuyw, false, 1, rsrxh, 0))
-                                                                                                                                                                                            , false
-                                                                                                                                                                                            , -(yhlaujkvk)
-                                                                                                                                                                                            )
-                                                                                                                                                                          , !(1 == (jnagczqp.irrqsabpiv(yhlaujkvk, jnagczqp, 5, jnagczqp, 5)))
-                                                                                                                                                                          , -(-(jnagczqp.irrqsabpiv(5, true, tggthuyw, false, tggthuyw)))
-                                                                                                                                                                          )
-                                                                                                                                                     ))
-      var sdgnir: Boolean = true
+      Console.println(-(2))
+      Console.println(((((-(4)).*(1 * 6)) * (0.*(1))) * (-((-(6)).*(-(4))))) * (-(0)))
       
-    } else {
-      Console.println
-        ( ((yhlaujkvk.*(4)) == ((2.<( jnagczqp.irrqsabpiv( -(yhlaujkvk)
-                                                         , rsrxh
-                                                         , true.irrqsabpiv( tggthuyw
-                                                                          , jnagczqp
-                                                                          , yhlaujkvk
-                                                                          , rsrxh
-                                                                          , 5
-                                                                          )
-                                                         , yhlaujkvk.==(yhlaujkvk)
-                                                         , rsrxh.irrqsabpiv( 6
-                                                                           , rsrxh
-                                                                           , yhlaujkvk
-                                                                           , true
-                                                                           , yhlaujkvk
-                                                                           )
-                                                         )
-                                    )).irrqsabpiv( 2
-                                                                                                  , ((rsrxh.irrqsabpiv( 2
-                                                                                                                      , false
-                                                                                                                      , 5
-                                                                                                                      , jnagczqp
-                                                                                                                      , yhlaujkvk
-                                                                                                                      )).==(6)).&&( yhlaujkvk == (jnagczqp.irrqsabpiv( yhlaujkvk
-                                                                                                                                                                               , jnagczqp
-                                                                                                                                                                               , yhlaujkvk
-                                                                                                                                                                               , rsrxh
-                                                                                                                                                                               , 0
-                                                                                                                                                                               ))
-                                                                                                                                            )
-                                                                                                  , tggthuyw
-                                                                                                  , false && (false.&&(2.==(yhlaujkvk)))
-                                                                                                  , (4.==(5.*(6))).irrqsabpiv(-(6), false, 6, false, -(tggthuyw))
-                                                                                                  ))).irrqsabpiv( -(yhlaujkvk)
-                                                                                                                                                                                                        , jnagczqp
-                                                                                                                                                                                                        , rsrxh.irrqsabpiv( jnagczqp.irrqsabpiv( yhlaujkvk.*(-(1))
-                                                                                                                                                                                                                                               , 0 < (true.irrqsabpiv( jnagczqp.irrqsabpiv(4, false, yhlaujkvk, rsrxh, yhlaujkvk)
-                                                                                                                                                                                                                                                                     , yhlaujkvk.<=(4)
-                                                                                                                                                                                                                                                                     , 1
-                                                                                                                                                                                                                                                                     , jnagczqp
-                                                                                                                                                                                                                                                                     , 4
-                                                                                                                                                                                                                                                                     ))
-                                                                                                                                                                                                                                               , 0
-                                                                                                                                                                                                                                               , (true.irrqsabpiv( yhlaujkvk
-                                                                                                                                                                                                                                                                 , !(jnagczqp)
-                                                                                                                                                                                                                                                                 , yhlaujkvk
-                                                                                                                                                                                                                                                                 , false.&&(rsrxh)
-                                                                                                                                                                                                                                                                 , yhlaujkvk
-                                                                                                                                                                                                                                                                 )) == (1.*(yhlaujkvk))
-                                                                                                                                                                                                                                               , (jnagczqp && jnagczqp).irrqsabpiv( 0
-                                                                                                                                                                                                                                                                                  , false
-                                                                                                                                                                                                                                                                                  , -(6)
-                                                                                                                                                                                                                                                                                  , (true.irrqsabpiv( 0
-                                                                                                                                                                                                                                                                                                    , false
-                                                                                                                                                                                                                                                                                                    , 2
-                                                                                                                                                                                                                                                                                                    , false
-                                                                                                                                                                                                                                                                                                    , yhlaujkvk
-                                                                                                                                                                                                                                                                                                    )).<( true.irrqsabpiv( 5
-                                                                                                                                                                                                                                                                                                                                   , false
-                                                                                                                                                                                                                                                                                                                                   , yhlaujkvk
-                                                                                                                                                                                                                                                                                                                                   , false
-                                                                                                                                                                                                                                                                                                                                   , 2
-                                                                                                                                                                                                                                                                                                                                   )
-                                                                                                                                                                                                                                                                                                                  )
-                                                                                                                                                                                                                                                                                  , tggthuyw
-                                                                                                                                                                                                                                                                                  )
-                                                                                                                                                                                                                                               )
-                                                                                                                                                                                                                          , rsrxh.&&(true.&&(false && false))
-                                                                                                                                                                                                                          , jnagczqp.irrqsabpiv( yhlaujkvk
-                                                                                                                                                                                                                                               , !(jnagczqp)
-                                                                                                                                                                                                                                               , 5
-                                                                                                                                                                                                                                               , 3 == (true.irrqsabpiv(3.*(tggthuyw), jnagczqp, -(3), rsrxh, 1))
-                                                                                                                                                                                                                                               , jnagczqp.irrqsabpiv( (yhlaujkvk == yhlaujkvk).irrqsabpiv( 2
-                                                                                                                                                                                                                                                                                                         , true.&&(jnagczqp)
-                                                                                                                                                                                                                                                                                                         , -(yhlaujkvk)
-                                                                                                                                                                                                                                                                                                         , false
-                                                                                                                                                                                                                                                                                                         , 3
-                                                                                                                                                                                                                                                                                                         )
-                                                                                                                                                                                                                                                                    , yhlaujkvk == tggthuyw
-                                                                                                                                                                                                                                                                    , yhlaujkvk
-                                                                                                                                                                                                                                                                    , false
-                                                                                                                                                                                                                                                                    , 4
-                                                                                                                                                                                                                                                                    )
-                                                                                                                                                                                                                                               )
-                                                                                                                                                                                                                          , !(rsrxh)
-                                                                                                                                                                                                                          , yhlaujkvk
-                                                                                                                                                                                                                          )
-                                                                                                                                                                                                        , false && jnagczqp
-                                                                                                                                                                                                        , yhlaujkvk
-                                                                                                                                                                                                        )
-        )
-      var cencqsr: Int = yhlaujkvk
+    else
+      Console.println(3)
       
-    }
-    var hbwkqm = 0
-    hbwkqm = 0
     
-  } : Unit
-  val qhuljmg = jnagczqp
-  var pytvvuoaa: Int = 0
-  if false then {
+  }
+  Console.println
+    (((((-(5)).+((5.*(0)).*(-(5)))) * (2.*(0))) * (((2 + (4.*(6))).*(4 * 2)) + 4)) + ((1 + ((3 * 6) * ((5 * 3) + 2))).+(((-(4)).*(-(4))) * (((-(3)).*(1.+(6))).*(3)))))
+  if (3 * ((-(6)).*(((-(5)).*(4)).*(4.*(5 * 2))))) == ((5.*(3 * 1)) + ((-((0.*(5)).+(2 * 4))) * (-((6.+(0)).*(5.*(3)))))) then {
+    def peamf(ubokgxik: Int, c: Boolean, upiip: Boolean, i: Boolean, z: Int, aznh: Int): Int =
+      extension (wbylxdxv: Int)
+        def afrclpzoc(iicczck: Int, qknu: Int, wmifrpwwnx: Boolean, sw: Boolean, mb: Boolean): Unit =
+          {} 
+      3 
     
   } else {
-    Console.println(5)
+    var iabbqoby = 5.<=(-(4.+(1)))
     
   }
-  var avdeqn = (((2 * 1).*(-(6 * 5))).*(-((0 * yhlaujkvk).*(yhlaujkvk)))).*(3)
+  var c: Int = (((-((-(4)).*(2))) * (6 * (2.*(3)))).*(0)) * ((6 * (1 * (3.*(1 * 1)))).*(((5 * (3 * 0)) * 5) * (-((4 + 5) * 3))))
+  extension (lzwsqc: Boolean) def mtwfgil(kcphro: Int, xywoinr: Boolean) = { (c.*((-(c * 0)) * ((kcphro * (2.*(2))).*(c.*(kcphro))))).*((c.*(2)).+(c)) } 
   
-} 
-val h = (((1.*(-(5.*(1)))) + 6).+(4.*(1))) <= ((3.+((2 * 5) * (2 * (6.*(0))))).*((-(5 * (-(5)))).*((-(-(1))) * (1 * 1))))
+} : Unit
 
 @main
-def vwordfka(): Unit = {
-  if (!((((1.*(0)).*(3)) * 0) == (1 * 6))).&&(h.&&(false && (5 <= 2))) then
-    extension (qzncoeqm: Int)
-      def nayr(mtwfg: Boolean, sdlglvqe: Boolean, itkhrnconn: Int): Int = {
-        vvw
-          ( ((-(qzncoeqm)) == ((((-(qzncoeqm)).*(2.*(qzncoeqm))) * 0).*(itkhrnconn.*((1.*(qzncoeqm)) * (2.*(2)))))).&&((true && true) && h)
-          , true.||(!(false))
-          , (-(qzncoeqm.*((0.*(itkhrnconn)).+(itkhrnconn.*(6))))).*(qzncoeqm * qzncoeqm)
-          )
-        if true then {
-          
-        } else {
-          
-        }
-        (-((qzncoeqm.*(5)) * (qzncoeqm.*(qzncoeqm)))) * 4
-      } : Int
-    var dfpxzc: Boolean =
-      (((2.*(4)).*( (-(-(1))).nayr( true
-                                  , 2.==(4)
-                                  , 4
-                                  )
-                  )).nayr( !(1 == ((5.nayr(false, h, 5)) + 3))
-                                                 , (-(1)) == ((2.nayr( false
-                                                                     , h
-                                                                     , 0
-                                                                     )).nayr( false.&&(h)
-                                                                                  , true
-                                                                                  , 4
-                                                                                  ))
-                                                 , 3
-                                                 )).<=( (-(2)).nayr( (6.nayr( h.&&(false)
-                                                                                                                          , false
-                                                                                                                          , (5.nayr( h
-                                                                                                                                   , h
-                                                                                                                                   , 5
-                                                                                                                                   )).nayr( true
-                                                                                                                                            , h
-                                                                                                                                            , 2.nayr( false
-                                                                                                                                                    , true
-                                                                                                                                                    , 5
-                                                                                                                                                    )
-                                                                                                                                            )
-                                                                                                                          )) == ((-(-(1))).nayr( false
-                                                                                                                                                                               , false
-                                                                                                                                                                               , 0.nayr( 3 == 6
-                                                                                                                                                                                       , 4 < 4
-                                                                                                                                                                                       , 1.nayr( true
-                                                                                                                                                                                               , true
-                                                                                                                                                                                               , 3
-                                                                                                                                                                                               )
-                                                                                                                                                                                       )
-                                                                                                                                                                               ))
-                                                                                                                 , ((5.nayr(4.==(6), 1.==(3), 1.*(3))).==(6)).&&(true)
-                                                                                                                 , (1 * 1) * 1
-                                                                                                                 )
-                                                                                                    )
-    var izqzkz = 3.==(2)
+def tcou(): Unit = {
+  if true then
+    var voukkkys = (4 + ((-(1)) + (1.*(3.*(1.*(0)))))) < 5
+    val kzt: Int = -((((3 * 1) * ((3 * 4) * (-(0)))).*(-(-(4)))) * ((-((4 * 4) * (2.+(2)))) * 5))
+    var b: Int = 0
+    Console.println(kzt * ((-(1)).*(1)))
     
   else
-    if (((((2.*(6)).*(2)).*(3.+(6.*(0)))).*((4 * 4).*(-(6)))) * ((((4 * 1).*(4.*(4))).*(1)).*(((1 + 2).*(3)) * 6))) == ((-(4.*(0))) * (-(3))) then {
-      var knunlwsi: Boolean = ((((6 * 0).*((0.*(4)).*(-(6)))) * (6.*((1 * 5) * 1))).*(5)).<=(0)
-      val imayj = (qxp: Int, upiip: Boolean, y: Boolean, bfauakmz: Boolean, ddfnjaz: Boolean, ve: Boolean) => { qxp } : Int
+    if true then
+      Console.println((-(2)).*((6.*(((4.+(2)).*(5 * 3)).+((0 * 4).*(-(6))))).*((4 * (5.*(4.+(6)))) + ((2.*(4.*(5))) * (-(3))))))
+      val rnk: Boolean = 5 <= 0
       
-    } else {
-      def fiofk(zpxmxnr: Boolean, rpwwnx: Int, pvyrnbxksw: Boolean, tfbwpipxeb: Boolean): Int = {
-        val bonhaiabb: Boolean = false
-        ((-(((-(rpwwnx)).*(4)).*(1))).*(rpwwnx.*(3))).*(-(rpwwnx))
-      } 
-      extension (t: Int) def hhg(xgry: Boolean): Int = { fiofk(true && true, 6, xgry, t.==(fiofk(true, t, h, !((!(h)) || h)))) } : Int
+    else
+      if (-((-(-(1))) + ((1.*(0 + 3)).*((1.*(5)) * (1.*(6)))))) < 0 then
+        if 1 < (-(0)) then
+          {}
+        else
+          extension (ngjd: Boolean)
+            def bfzhigtu(nkvmxks: Int, vbr: Int): Unit =
+              {} 
+          
+        Console.println(((4.*((3.*(4.*(1))) + ((-(3)).*(5.*(6))))).*(2)).*(1))
+        
+      Console.println((4.*((-(5)) * (6 * (-(5))))) * ((4.*(1.*(5))) * ((6 * 0).*(4.*(-(4 * 0))))))
+      if 3 <= 4 then {
+        
+      }
       
-    }
-    val cisoebm = (amfmg: Int, s: Int) => {
-      vvw(true, false, (-(s * (0 * amfmg))).*((-(-((0.*(1)).*(6)))).*(((amfmg.*(4)).*(amfmg.*(6 + 0))) * amfmg)))
-      amfmg.*(4)
-    } : Int
-    var wfxyk: Int = 2.*(cisoebm(-(2 * 5), (-(6)).*(0)))
+    extension (c: Boolean)
+      def qzis(xkmfsklg: Boolean) =
+        Console.println(((-(((1 + 3) + 5).*((-(5)).*(6.*(1))))).*((5.+(3)).+(4 * 1))).*(2.*(((4.*(2)) * (5 + (0 * 1))).*(-(3)))))
+        ((-(4 * ((4.*(1)) * (-(0))))) * (2 * ((1.*(5 * 0)).*((5.*(1)).+(1))))) + (((-(5)) * (2.*(6.*(5)))).*(2 * 0)) 
+    def im(blitkf: Int) = {
+      val cboohd =
+        (((blitkf * 2) * (((true.qzis(true)) < (true qzis true)).qzis(true))) < (blitkf * (-(-(0))))).qzis((true qzis ((true qzis true) < blitkf)) < ((0 + blitkf).*(blitkf)))
+      blitkf
+    } 
+    val ihredpvgxa = (ejvib: Boolean, sugy: Int, bgmuf: Int, kgsqtsdoja: Boolean) =>
+      (6) : Int
     
-  if ((((4.*(6 * 0)).*(6.*(1))) * (-((2 * 1).*(6.*(0))))) <= (2.*(3))).&&(((((5.*(2)).==(1)) && h).||(((0.+(1)) * (5.+(2))) < 4)).&&(((-(4.*(5))).*(4)).==(4))) then {
-    extension (gbwvichlrj: Boolean) def kcgyoqzlh(exvayfl: Boolean, byvljjd: Int, khbvvhvwex: Int): Unit = {  } : Unit
-    if false.&&(!(true)) then {
-      
-    } else {
-      
-    }
+  kki()
+  def idthitejb(uyahokypoa: Boolean, m: Int, mua: Boolean, fdfpxzc: Int, qzkzqyfibo: Int, yotgmawju: Boolean): Unit = {  } 
+  if ((-(0 + 4)) * (0 + (-(-(5))))) < (-(1 * (0.*(0)))) then {
+    if ((-(3.*(1))).*(((0 + (-(4))).*(6)) * 1)).<((3 * (-((0 + 3).*(0)))).*(((-(1.*(0))).*(1.+(0))).*(1))) then
+      {}
+    else
+      {}
     
   } else {
-    def gkwdxzlt(wgavser: Boolean) =
-      vvw
-        ( 0 == (3.*((6 * ((1 * 0) * (6.*(2)))) * 2))
-        , (!(h)) && h
-        , (0 * ((((3.*(3)).*(2)).*(3 * (-(3)))).+((3.*(0.*(5))) * (5 * 1)))).*((((2 * (0 * 2)).*((6.*(4)) * 3)) * (2.*(-(0)))) * 3)
-        )
-      (((6 + ((4 * 3).*(2))).*(-(6))).==(2.*(((0 * 2) * 0) * ((6 * 6) * 1)))) && ((2.*(((4 * 6).*(-(5))).*((0.*(5)) * 2))) <= (-(-(1)))) 
-    def w(): Boolean =
-      (-((5 * 4).*(((1 + 4) * (1.*(2))).*(1.*(2 * 5))))) == (-((-(1)) * (5 * 6))) 
+    extension (huj: Boolean) def qcxve(ginvqeeku: Int, in: Boolean) = { -((-(ginvqeeku)).+((-((-(1)) * ginvqeeku)) * (4.*(6.*(1))))) } 
     
   }
-  var ykazxklxll = ((((-(6 * 1)).*(4)) * (6.*(-(1)))) * ((5 * ((5 * 3) * 4)) * (((6.*(3)) * 6) + 1))) * 6
+  var qrf = -(-(3))
   
 }
diff --git a/examples/pil-fun/tests/lang/usage/UsePil.idr b/examples/pil-fun/tests/lang/usage/UsePil.idr
index aa416077f..5591a4384 100644
--- a/examples/pil-fun/tests/lang/usage/UsePil.idr
+++ b/examples/pil-fun/tests/lang/usage/UsePil.idr
@@ -67,7 +67,7 @@ failing "Can't find an implementation for AtIndex"
     1 #= F Plus [< V 0, V 0]
     Nop
 
-failing #"Can't find an implementation for LTE 3 (length ([<Int'] Mutable))"#
+failing #"Can't find an implementation for LTE 3 (length [<(Int', Mutable)])"#
   bad : Stmts StdF [<] Nothing
   bad = do
     NewV Int' {- 0 -} Mutable $ C 0
@@ -75,7 +75,7 @@ failing #"Can't find an implementation for LTE 3 (length ([<Int'] Mutable))"#
     2 #= V 0
     Nop
 
-failing #"Can't find an implementation for LTE 3 (length ([<Int'] Mutable))"#
+failing #"Can't find an implementation for LTE 3 (length [<(Int', Mutable)])"#
   bad : Stmts StdF [<] Nothing
   bad = do
     NewV Int' {- 0 -} Mutable $ C 0
diff --git a/src/Deriving/DepTyCheck/Gen/ForAllNeededTypes/Impl.idr b/src/Deriving/DepTyCheck/Gen/ForAllNeededTypes/Impl.idr
index 23ccfd6a6..3bda802ed 100644
--- a/src/Deriving/DepTyCheck/Gen/ForAllNeededTypes/Impl.idr
+++ b/src/Deriving/DepTyCheck/Gen/ForAllNeededTypes/Impl.idr
@@ -5,12 +5,16 @@ import public Control.Monad.State
 
 import public Data.DPair
 import public Data.List.Set
+import public Data.List.Ex
+import public Data.List.Map
 import public Data.SortedMap
 
 import public Decidable.Equality
 
 import public Deriving.DepTyCheck.Gen.ForOneType.Interface
 
+import public Deriving.DepTyCheck.Util.Specialisation
+
 %default total
 
 --- Particular implementations producing the-core-derivation-function closure ---
@@ -69,9 +73,14 @@ DeriveBodyForType => ClosuringContext m => Elaboration m => SortedMap GenSignatu
     -- check if internal generator asked for is for a primitive type
     when (isTypeInfoPrim sig.targetType) $
       fail "Cannot derive generator for the primitive type \{show $ extractTargetTyExpr sig.targetType}, use external instead"
+    notfound <- pure $ id $ not $ List.Set.contains sig %search
+
+    sinRet : Maybe TTImp <- if notfound then assert_total specialiseIfNeeded sig fuel values else pure Nothing
+    let Nothing = sinRet
+      | Just me => pure (me, Nothing)
 
     -- remember the task to derive, if necessary
-    when (not $ List.Set.contains sig %search) $ do
+    when notfound $ do
       modify $ if isTypeKnown sig.targetType then mapFst $ normalise . List.Set.insert sig else mapSnd $ normalise . List.Set.insert sig
 
     -- call the internal gen
diff --git a/src/Deriving/DepTyCheck/Util/Specialisation.idr b/src/Deriving/DepTyCheck/Util/Specialisation.idr
new file mode 100644
index 000000000..590e8e749
--- /dev/null
+++ b/src/Deriving/DepTyCheck/Util/Specialisation.idr
@@ -0,0 +1,361 @@
+module Deriving.DepTyCheck.Util.Specialisation
+
+import public Control.Monad.Either
+
+import public Data.DPair
+import public Data.List.Ex
+import public Data.List.Map
+import public Data.SortedMap
+import public Data.SortedMap.Extra
+import public Data.SortedSet
+
+import public Deriving.DepTyCheck.Gen.ForOneType.Interface
+
+import public Deriving.SpecialiseData
+import public Language.Reflection.Unify
+
+import public Data.Hashable
+import public Data.Hashable.Base
+
+%default total
+
+||| All argument values applied in an expression
+|||
+||| Used for convenience when traversing given arguments and their types
+record AllApps where
+  constructor MkAllApps
+  explicitArgs : List TTImp
+  autoArgs : List TTImp
+  namedArgs : SortedMap Name TTImp
+
+||| Insert an `AnyApp` into `AllApps`
+addApp' : AnyApp -> AllApps -> AllApps
+addApp' (PosApp s) = {explicitArgs $= (s ::)}
+addApp' (NamedApp nm s) = {namedArgs $= insert nm s}
+addApp' (AutoApp s) = {autoArgs $= (s ::)}
+addApp' (WithApp s) = {explicitArgs $= (s ::)}
+
+||| Make an `AllApps` out of a list of `AnyApp`
+|||
+||| Used in conjunction with `unAppAny`
+mkAllApps : List AnyApp -> AllApps
+mkAllApps laa = foldl (flip addApp') (MkAllApps [] [] empty) $ reverse laa
+
+||| Pop a value from `AllApps` by argument name
+|||
+||| The argument/value is returned from `AllApps`
+getNamed : Maybe Name -> AllApps -> (Maybe TTImp, AllApps)
+getNamed Nothing ap = (Nothing, ap)
+getNamed (Just x) ap =
+  case lookup x ap.namedArgs of
+    Nothing => (Nothing, ap)
+    Just t => (Just t, {namedArgs $= delete x} ap)
+
+||| Pop an argument value from `AllApps`, returning Nothing if no value is given
+|||
+||| The argument/value is returned from `AllApps`
+getGiven : Arg -> AllApps -> (Maybe TTImp, AllApps)
+getGiven (MkArg _ ImplicitArg name _) ap = getNamed name ap
+getGiven (MkArg _ ExplicitArg name _) (MkAllApps (x :: xs) autoArgs namedArgs) = (Just x, MkAllApps xs autoArgs namedArgs)
+getGiven (MkArg _ ExplicitArg name _) ap = getNamed name ap
+getGiven (MkArg _ AutoImplicit name _) (MkAllApps explicitArgs (x :: xs) namedArgs) = (Just x, MkAllApps explicitArgs xs namedArgs)
+getGiven (MkArg _ AutoImplicit name _) ap = getNamed name ap
+getGiven (MkArg _ (DefImplicit x) Nothing _) ap = (Just x, ap)
+getGiven (MkArg _ (DefImplicit x) (Just n) _) ap =
+  case lookup n ap.namedArgs of
+    Nothing => (Just x, ap)
+    Just t => (Just t , {namedArgs $= delete n} ap)
+
+||| Extract given values of arguments from `AllApps`
+getGivens : List Arg -> AllApps -> List (Maybe TTImp)
+getGivens [] aa = []
+getGivens (x :: xs) aa = do
+  let (mr, aa) = getGiven x aa
+  mr :: getGivens xs aa
+
+allQImpl : Monad m => NamesInfoInTypes => TTImp -> m TTImp -> m TTImp
+allQImpl pi@(IPi _ _ _ _ _ _) r = r
+allQImpl app@(IApp _ _ _) r = do
+  IApp _ procL _ <- r
+    | _ => pure `(?)
+  case procL of
+    Implicit _ _ => pure `(?)
+    _ => r
+allQImpl v@(IVar _ n) _ =
+  case lookupType n of
+    Just _ => pure v
+    Nothing => pure `(?)
+allQImpl _ _ = pure `(?)
+
+||| Replace every non-function sub-expression with a question mark
+|||
+||| (x -> (y -> z) -> q) becomes (? -> (? -> ?) -> ?)
+allQuestions : NamesInfoInTypes => TTImp -> TTImp
+allQuestions t = runIdentity $ mapATTImp' allQImpl t
+
+||| An abstract "argument" of a generator
+|||
+||| Consists of a type constructor's argument and a possible given value
+record GenArg where
+  constructor MkGenArg
+  arg : Arg
+  given : Maybe TTImp
+
+LogPosition GenArg where
+  logPosition (MkGenArg a Nothing) = "\{fromMaybe "" a.name}"
+  logPosition (MkGenArg a $ Just t) = "(\{fromMaybe "" a.name} := \{show t})"
+
+unGA : List GenArg -> (List Arg, List (Maybe TTImp))
+unGA [] = ([], [])
+unGA (x :: xs) = let (ys, zs) = unGA xs in (x.arg :: ys, x.given :: zs)
+
+(.isGenerated) : GenArg -> Bool
+(.isGenerated) = isNothing . given
+
+(.isGiven) : GenArg -> Bool
+(.isGiven) = isJust . given
+
+||| Determine if the argument should be specialised or passed through
+(.isSpecialising) : Elaboration m => GenArg -> m Bool
+(.isSpecialising) (MkGenArg a Nothing) = pure False
+(.isSpecialising) (MkGenArg a $ Just g) = do
+  let True = snd (unPi a.type) == `(Type)
+    | _ => pure False
+  case g of
+    IVar _ n => do
+      nInfo <- getInfo n
+      case nInfo of
+        [] => pure False
+        _ => pure True
+    _ => pure True
+
+||| Extracts given values of arguments from a type invocation expression
+export
+getGivens' : NamesInfoInTypes => TTImp -> Maybe (List GenArg)
+getGivens' t = do
+  let (IVar _ tyName, aTerms) = unAppAny t
+    | _ => Nothing
+  let Just tyInfo = lookupType tyName
+    | _ => Nothing
+  Just $ map (uncurry MkGenArg) $ zip tyInfo.args $ getGivens tyInfo.args (mkAllApps aTerms)
+
+||| Assemble a list of arguments and their given values from `callGen` inputs
+mkArgs :
+  NamesInfoInTypes =>
+  (sig : GenSignature) ->
+  List (Fin sig.targetType.args.length, Arg) ->
+  List (Fin sig.targetType.args.length, TTImp) ->
+  List GenArg
+mkArgs sig [] _ = []
+mkArgs sig ((_, x) :: xs) [] = MkGenArg x Nothing :: mkArgs sig xs []
+mkArgs sig ((i1, x) :: xs) g@((i2, y) :: ys) =
+  if i1 == i2
+    then MkGenArg x (Just y) :: mkArgs sig xs ys
+    else MkGenArg x Nothing  :: mkArgs sig xs g
+
+singleArg : NamesInfoInTypes => Nat -> GenArg -> (TTImp, List GenArg)
+singleArg n (MkGenArg a v) = do
+  let n : Name = fromString "lam^\{show n}"
+  (IVar EmptyFC n, [MkGenArg (MkArg a.count a.piInfo (Just n) $ allQuestions a.type) v])
+
+processArg : MonadLog m => NamesInfoInTypes => GenSignature -> Nat -> GenArg -> m (TTImp, List GenArg)
+
+processArgs' : MonadLog m => NamesInfoInTypes => GenSignature -> Nat -> List GenArg -> m (List AnyApp, List GenArg)
+processArgs' sig k [] = pure ([], [])
+processArgs' sig k (x :: xs) = do
+  (aT, l) <- assert_total $ processArg sig k x
+  (recAA, l') <- processArgs' sig (k + length l) xs
+  pure (appArg x.arg aT :: recAA, l ++ l')
+
+processArg sig argIdx ga with (ga.given)
+  processArg sig argIdx ga | Nothing = do
+    logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga] "No given value, passing through"
+    pure $ singleArg argIdx ga
+  processArg sig argIdx ga | Just x = do
+    let (appLhs, appTerms) = unAppAny x
+    let IVar _ tyName = appLhs
+      | IPrimVal _ (PrT _) => do
+            logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga] "Given a primitive type invocation, specialising"
+            pure (x, [])
+      | _ => do
+        logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga] "Given value head is not a variable, passing through"
+        pure $ singleArg argIdx ga
+    case lookupType tyName of
+      Just tyInfo => do
+        let (_ :: _) = appTerms
+          | [] => do
+            logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga] "Given a type invocation w/o arguments, specialising"
+            pure (x, [])
+        let givens = map (uncurry MkGenArg) $ zip tyInfo.args $ getGivens tyInfo.args (mkAllApps appTerms)
+        logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga]
+          "Given a type invocation, traversing arguments: \{show $ map (fromMaybe "" . name . arg) givens}"
+        map (mapFst $ reAppAny appLhs) $ processArgs' sig argIdx $ takeWhile (.isGiven) givens
+      Nothing => do
+        if (snd (unPi ga.arg.type) == `(Type))
+          then do
+            logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga] "Given a non-global type expr, passing through"
+            -- pure (x, [])
+            pure $ singleArg argIdx ga
+          else do
+            logPoint DetailedDebug "deptycheck.util.specialisation" [sig, ga] "Given a non-type expr, passing through"
+            pure $ singleArg argIdx ga
+
+processArgs :
+  MonadLog m =>
+  NamesInfoInTypes =>
+  (sig : GenSignature) ->
+  List GenArg ->
+  m (TTImp, List Arg, List $ Maybe TTImp)
+processArgs sig ga = map (bimap (reAppAny $ IVar EmptyFC sig.targetType.name) unGA) $ processArgs' sig 0 ga
+
+export
+formGivenVals : Vect l _ -> List TTImp -> Vect l TTImp
+formGivenVals []        _         = []
+formGivenVals (_ :: xs) []        = `(_) :: formGivenVals xs []
+formGivenVals (x :: xs) (y :: ys) = y    :: formGivenVals xs ys
+
+genGivens : List (TTImp, Fin x, Arg) -> (s : SortedSet (Fin x) ** Vect s.size TTImp)
+genGivens l = do
+  let (l1, l2, l3) = unzip3 l
+  let s = SortedSet.fromList l2
+  let gv = formGivenVals (Vect.fromList $ Prelude.toList s) l1
+  (s ** gv)
+
+specTaskToName : TTImp -> Name
+specTaskToName t = do
+  let (_, lamBody) = unLambda t
+  let (callee, _) = unAppAny lamBody
+  let vname =
+    case callee of
+         (IVar _ n) => show $ snd $ unNS n
+         x => show x
+  fromString "\{vname}^\{show $ hash t}"
+
+-- Using the monadic trick makes the performance *much* better.
+specTaskToName' : Monad m => TTImp -> m Name
+specTaskToName' t = do
+  let (_, lamBody) = unLambda t
+  let (callee, _) = unAppAny lamBody
+  let vname =
+    case callee of
+         (IVar _ n) => show $ snd $ unNS n
+         x => show x
+  hash <- pure $ show $ hash t
+  pure $ fromString "\{vname}^\{hash}.\{vname}^\{hash}"
+
+nameUnambigAndVis : Elaboration m => Name -> m Bool
+nameUnambigAndVis n = do
+  try (do
+    _ : Unit <- check `(let x = ~(var n) in ())
+    pure True) (pure False)
+
+allConstructorsVisible : Elaboration m => TypeInfo -> m Bool
+allConstructorsVisible ti = do
+  all id <$> traverse nameUnambigAndVis (name <$> ti.cons)
+
+mkDPairHelper : Nat -> (Name -> TTImp) -> TTImp -> TTImp
+mkDPairHelper 0 _ t = t
+mkDPairHelper (S n) helper t = do
+  let nn = fromString $ "dph^\{show n}"
+  `(MkDPair ~(helper nn) ~(mkDPairHelper n helper t))
+
+dPairHelper : Nat -> TTImp
+dPairHelper 0 = `(?)
+dPairHelper (S n) = `(DPair ? $ \_ => ~(dPairHelper n))
+
+inSameNS : Name -> Name -> Name
+inSameNS (NS ns _) n = NS ns n
+inSameNS _ n = n
+
+export %tcinline
+specialiseIfNeeded :
+  Elaboration m =>
+  NamesInfoInTypes =>
+  ConsRecs =>
+  DerivationClosure m =>
+  (sig : GenSignature) ->
+  (fuel : TTImp) ->
+  Vect sig.givenParams.size TTImp ->
+  m $ Maybe TTImp
+specialiseIfNeeded sig fuel givenParamValues = do
+  logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Checking specialisation need for \{show givenParamValues}..."
+  -- Check if there are any given type args, if not return Nothing
+  let True = any (\a => snd (unPi a.type) == `(Type)) $ index' sig.targetType.args <$> Prelude.toList sig.givenParams
+    | False => do
+      logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Not found any given type args, specialisation not needed."
+      pure Nothing
+  -- Check if all of the generated type's constructors are visible, if not return Nothing
+  True <- allConstructorsVisible sig.targetType
+    | False => do
+      logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "\{sig.targetType.name} has invisible constructors, specialisation impossible."
+      pure Nothing
+  -- Assemble the `GenArg`s from `GenSignature` and given values
+  let givenIdxVals = Prelude.toList sig.givenParams `zipV` givenParamValues
+  let genArgs = mkArgs sig (withIndex sig.targetType.args) givenIdxVals
+  -- Check if at least one `GenArg` can be specialised upon (i.e. is a type argument and has a non-passthrough given value)
+  specable <- traverse (.isSpecialising) genArgs
+  let True = any id specable
+    | False => do
+      logPoint DetailedDebug "deptycheck.util.specialisation" [sig]
+        "Not found any type arguments that can be specialised upon, specialisation impossible."
+      pure Nothing
+  -- Generate specialisation rhs, arguments, and given values
+  (lambdaRet, fvArgs, givenSubst) <- processArgs sig genArgs
+  let preNorm = foldr lam lambdaRet fvArgs
+  logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Task before normalisation: \{show preNorm}"
+  -- Normalise the specialisation lambda
+  (lambdaTy, lambdaBody) <- normaliseTask fvArgs lambdaRet
+  logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "NormaliseTask returned: lambdaTy = \{show lambdaTy};"
+  logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "                        lambdaBody = \{show lambdaBody};"
+  -- Generate specialised type name
+  specName <- specTaskToName' lambdaBody
+  logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Specialised type name: \{show specName}"
+  -- Check if `NamesInfoInTypes` contains specialised type
+  (specTy, specDecls) : (TypeInfo, List Decl) <- case lookupType specName of
+    -- If not, try looking it up via elaborator
+    Nothing => do
+      info <- try (Just <$> getInfo' specName) (pure Nothing)
+      case info of
+        Nothing => do
+        -- If not found at all, derive specialised type
+          logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Specialised type not found, deriving..."
+          thisNS <- do
+            NS nsn _ <- inCurrentNS ""
+            | _ => fail "Internal error: inCurrentNS did not return NS"
+            pure nsn
+          Right (specTy, specDecls) <- runEitherT {m} {e=SpecialisationError} $
+              specialiseDataRaw {nsProvider = inNS thisNS} specName lambdaTy lambdaBody
+            | Left err => fail "INTERNAL ERROR: Specialisation \{show lambdaBody} failed with error \{show err}."
+          logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Derived \{show specTy.name}"
+          -- Declare derived type
+          declare specDecls
+          specTy <- getInfo' specName
+          logPoint Trace "deptycheck.util.specialisation" [sig] "Declared specialised type \{show specTy.name}: \{show lambdaRet}"
+          pure (specTy, [])
+        Just specTy => do
+          logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Found \{show specTy.name}"
+          pure (specTy, [])
+    Just specTy => do
+      logPoint DetailedDebug "deptycheck.util.specialisation" [sig] "Found \{show specTy.name}"
+      pure (specTy, [])
+  -- Assert that all of the specialised type's arguments are named for the specialised generator's `GenSignature` (this property should always be true)
+  let Yes stNamed = areAllTyArgsNamed specTy
+    | No _ => fail "INTERNAL ERROR: Specialised type \{show specTy.name} does not have fully named arguments and constructors."
+  -- Form new givens set and given value list
+  let (newGP ** newGVals) = genGivens $ mapMaybe (\(a,b) => map (,b) a) $ zip givenSubst $ withIndex specTy.args
+  -- Obtain the specialised generator call
+  (inv, cg_rhs) <- callGen (MkGenSignature specTy newGP) fuel newGVals
+  let inv : TTImp = case cg_rhs of
+        Nothing => inv
+        Just (n ** perm) => reorderGend False perm inv
+  -- Use derived cast to convert result back to polymorphic type
+  let generateds = sig.targetType.args.length `minus` sig.givenParams.size
+  let inv : TTImp =
+    if generateds == 0
+        then `(map (cast @{~(var $ inSameNS specTy.name "mToP")}) $ ~inv)
+        else
+          `(the (Gen MaybeEmpty ~(dPairHelper generateds)) $ map (\invv =>
+            case invv of
+              ~(mkDPairHelper generateds bindVar (bindVar "inv")) =>
+                  ~(mkDPairHelper generateds var `(cast @{~(var $ inSameNS specTy.name "mToP")} inv))) ~inv)
+  pure $ Just inv
diff --git a/tests/.clean-names b/tests/.clean-names
index 6bb530638..ff801eaf9 100755
--- a/tests/.clean-names
+++ b/tests/.clean-names
@@ -1,4 +1,4 @@
-#!/bin/awk -f
+#!/usr/bin/env -S awk -f
 
 # consistently replace numbers to make golden tests more stable. Currently handles:
 #   arg:NNN
diff --git a/tests/Tests.idr b/tests/Tests.idr
index 32e3a8c9d..782573465 100644
--- a/tests/Tests.idr
+++ b/tests/Tests.idr
@@ -12,10 +12,11 @@ main = goldenRunner $
   , "Derivation utils: canonic signature" `atDir` "derivation/utils/canonicsig"
   , "Derivation utils: constructors analysis" `atDir` "derivation/utils/cons-analysis"
   , "Derivation utils: order tuning" `atDir` "derivation/utils/order-tuning"
+  , "Derivation utils: specialise if needed" `atDir` "derivation/utils/specialise-if-needed"
   , "Derivation: input validation" `atDir` "derivation/inputvalidation"
   , "Derivation: running harness" `atDir` "derivation/infra"
   , [ "Derivation: least effort (\{p}, \{w})" `atDir` "derivation/least-effort/\{p}/\{w}"
-    | p <- ["print", "run"], w <- ["adt", "gadt", "john-hughes", "order", "regression"]
+    | p <- ["print", "run"], w <- ["adt", "gadt", "john-hughes", "order", "regression", "specialise"]
     ]
   , "Derivation: core" `atDir` "derivation/core"
   , "Derivation: distribution" `atDir` "derivation/distribution"
diff --git a/tests/derivation/_common/run b/tests/derivation/_common/run
index dce1363e6..314f04286 100755
--- a/tests/derivation/_common/run
+++ b/tests/derivation/_common/run
@@ -4,7 +4,7 @@ NAMES_CLEANER="$(dirname "$(dirname "$(realpath "$1")")")"/.clean-names
 
 {
 flock "$1" pack -q install-deps derive.ipkg && \
-idris2 --check --no-color --console-width 0 --no-banner --find-ipkg DerivedGen.idr && \
+idris2 --check --no-color --console-width 0 --no-banner --find-ipkg --log "deptycheck.util.specialisation:10" DerivedGen.idr && \
 pack exec DerivedGen.idr
 } | "$NAMES_CLEANER"
 
diff --git a/tests/derivation/core/norec part noext 003/expected b/tests/derivation/core/norec part noext 003/expected
index d1ae36b68..1b0cf7bda 100644
--- a/tests/derivation/core/norec part noext 003/expected	
+++ b/tests/derivation/core/norec part noext 003/expected	
@@ -1,12 +1,25 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: Unsupported applications to a non-concrete type `ty` in Prelude.Types.Just
-
-DerivedGen:1
- 12 | XShow : Show X
- 13 | XShow = %runElab derive
- 14 |
- 15 | checkedGen : Fuel -> Gen MaybeEmpty X
- 16 | checkedGen = deriveGen
-                   ^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Prelude.Types.Maybe[0(ty)] Declared specialised type DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926: Prelude.Types.Maybe Prelude.Basics.Bool
+Generated values:
+-----
+-----
+MkX (Just False)
+-----
+MkX Nothing
+-----
+MkX Nothing
+-----
+MkX Nothing
+-----
+MkX (Just True)
+-----
+MkX (Just True)
+-----
+MkX (Just False)
+-----
+MkX (Just True)
+-----
+MkX Nothing
+-----
+MkX Nothing
diff --git a/tests/derivation/core/norec part noext 004/expected b/tests/derivation/core/norec part noext 004/expected
index f1988b3a7..8b2a26bf5 100644
--- a/tests/derivation/core/norec part noext 004/expected	
+++ b/tests/derivation/core/norec part noext 004/expected	
@@ -1,12 +1,25 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: Unsupported applications to a non-concrete type `a` in Builtin.MkPair
-
-DerivedGen:1
- 13 | XShow = %runElab derive
- 14 |
- 15 | export
- 16 | checkedGen : Fuel -> Gen MaybeEmpty X
- 17 | checkedGen = deriveGen
-                   ^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Builtin.Pair[0, 1] Declared specialised type DerivedGen.Pair^2851741735237823607.Pair^2851741735237823607: Builtin.Pair Prelude.Basics.Bool Prelude.Basics.Bool
+Generated values:
+-----
+-----
+MkX (True, False)
+-----
+MkX (False, False)
+-----
+MkX (False, True)
+-----
+MkX (True, True)
+-----
+MkX (True, True)
+-----
+MkX (False, True)
+-----
+MkX (True, False)
+-----
+MkX (False, True)
+-----
+MkX (False, False)
+-----
+MkX (True, True)
diff --git a/tests/derivation/core/norec part noext 005/expected b/tests/derivation/core/norec part noext 005/expected
index f1988b3a7..90102d258 100644
--- a/tests/derivation/core/norec part noext 005/expected	
+++ b/tests/derivation/core/norec part noext 005/expected	
@@ -1,12 +1,26 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: Unsupported applications to a non-concrete type `a` in Builtin.MkPair
-
-DerivedGen:1
- 13 | XShow = %runElab derive
- 14 |
- 15 | export
- 16 | checkedGen : Fuel -> Gen MaybeEmpty X
- 17 | checkedGen = deriveGen
-                   ^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Prelude.Types.Maybe[0(ty)] Declared specialised type DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926: Prelude.Types.Maybe Prelude.Basics.Bool
+LOG deptycheck.util.specialisation:10: Builtin.Pair[0, 1] Declared specialised type DerivedGen.Pair^2851741735237823607.Pair^2851741735237823607: Builtin.Pair Prelude.Basics.Bool Prelude.Basics.Bool
+Generated values:
+-----
+-----
+X1 Nothing
+-----
+X0
+-----
+X0
+-----
+X0
+-----
+X1 (Just True)
+-----
+X0
+-----
+X1 (Just False)
+-----
+X0
+-----
+X0
+-----
+X2 True (True, True)
diff --git a/tests/derivation/core/norec part w_ext 001/expected b/tests/derivation/core/norec part w_ext 001/expected
index db192f8fc..e22591703 100644
--- a/tests/derivation/core/norec part w_ext 001/expected	
+++ b/tests/derivation/core/norec part w_ext 001/expected	
@@ -1,12 +1,25 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: Unsupported applications to a non-concrete type `ty` in Prelude.Types.Just
-
-DerivedGen:1
- 13 | XShow = %runElab derive
- 14 |
- 15 | export
- 16 | checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
- 17 | checkedGen = deriveGen
-                   ^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Prelude.Types.Maybe[0(ty)] Declared specialised type DerivedGen.Maybe^13367506090110851422.Maybe^13367506090110851422: Prelude.Types.Maybe String
+Generated values:
+-----
+-----
+MkX (Just "")
+-----
+MkX Nothing
+-----
+MkX Nothing
+-----
+MkX Nothing
+-----
+MkX (Just "a")
+-----
+MkX (Just "")
+-----
+MkX (Just "a")
+-----
+MkX Nothing
+-----
+MkX Nothing
+-----
+MkX (Just "")
diff --git a/tests/derivation/core/norec part w_ext 002/expected b/tests/derivation/core/norec part w_ext 002/expected
index df08e4fc2..f928a418d 100644
--- a/tests/derivation/core/norec part w_ext 002/expected	
+++ b/tests/derivation/core/norec part w_ext 002/expected	
@@ -1,12 +1,25 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: Unsupported applications to a non-concrete type `a` in Builtin.MkPair
-
-DerivedGen:1
- 13 | XShow = %runElab derive
- 14 |
- 15 | export
- 16 | checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => (Fuel -> Gen MaybeEmpty Nat) => Gen MaybeEmpty X
- 17 | checkedGen = deriveGen
-                   ^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Builtin.Pair[0, 1] Declared specialised type DerivedGen.Pair^3343132386166297942.Pair^3343132386166297942: Builtin.Pair String Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX ("a", 0)
+-----
+MkX ("", 0)
+-----
+MkX ("", 10)
+-----
+MkX ("a", 10)
+-----
+MkX ("", 10)
+-----
+MkX ("a", 0)
+-----
+MkX ("", 10)
+-----
+MkX ("", 0)
+-----
+MkX ("a", 10)
+-----
+MkX ("a", 10)
diff --git a/tests/derivation/core/norec part w_ext 003/expected b/tests/derivation/core/norec part w_ext 003/expected
index df08e4fc2..7ce1b8f9e 100644
--- a/tests/derivation/core/norec part w_ext 003/expected	
+++ b/tests/derivation/core/norec part w_ext 003/expected	
@@ -1,12 +1,26 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: Unsupported applications to a non-concrete type `a` in Builtin.MkPair
-
-DerivedGen:1
- 13 | XShow = %runElab derive
- 14 |
- 15 | export
- 16 | checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => (Fuel -> Gen MaybeEmpty Nat) => Gen MaybeEmpty X
- 17 | checkedGen = deriveGen
-                   ^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Builtin.Pair[0, 1] Declared specialised type DerivedGen.Pair^11732935965551223900.Pair^11732935965551223900: Builtin.Pair String (Builtin.Pair Prelude.Types.Nat String)
+LOG deptycheck.util.specialisation:10: Builtin.Pair[0, 1] Declared specialised type DerivedGen.Pair^1493320044233062328.Pair^1493320044233062328: Builtin.Pair Prelude.Types.Nat String
+Generated values:
+-----
+-----
+MkX ("", (10, ""))
+-----
+MkX ("a", (0, ""))
+-----
+MkX ("", (10, "a"))
+-----
+MkX ("bc", (10, "a"))
+-----
+MkX ("bc", (0, ""))
+-----
+MkX ("a", (10, "a"))
+-----
+MkX ("", (10, ""))
+-----
+MkX ("a", (0, "a"))
+-----
+MkX ("bc", (0, ""))
+-----
+MkX ("a", (10, "bc"))
diff --git a/tests/derivation/core/norec t-pi--.. noext 003/expected b/tests/derivation/core/norec t-pi--.. noext 003/expected
index fb9423664..ff38df45d 100644
--- a/tests/derivation/core/norec t-pi--.. noext 003/expected	
+++ b/tests/derivation/core/norec t-pi--.. noext 003/expected	
@@ -1,7 +1,48 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: While processing right hand side of $resolved1,<Builtin.Equal>[0, 1, 2, 3]. While processing right hand side of $resolved1,<Builtin.Equal>[0, 1, 2, 3],<<Builtin.Refl>>. Can't find an implementation for DecEq Type.
-
-Deriving.DepTyCheck.Gen.ForOneTypeCon.Impl:1
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Builtin.Equal[0(a), 1(b), 2, 3] Declared specialised type DerivedGen.Equal^17761735534830529519.Equal^17761735534830529519: Builtin.Equal {a = Prelude.Basics.Bool} {b = Prelude.Basics.Bool} lam^0 lam^1
+Generated values:
+-----
+-----
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+MkX True True Refl
+-----
+-----
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
+-----
+MkX False False Refl
diff --git a/tests/derivation/core/norec t-pi--.. noext 004/expected b/tests/derivation/core/norec t-pi--.. noext 004/expected
index fb9423664..736e5465d 100644
--- a/tests/derivation/core/norec t-pi--.. noext 004/expected	
+++ b/tests/derivation/core/norec t-pi--.. noext 004/expected	
@@ -1,7 +1,88 @@
 1/2: Building RunDerivedGen (RunDerivedGen.idr)
 2/2: Building DerivedGen (DerivedGen.idr)
-Error: While processing right hand side of checkedGen. Error during reflection: While processing right hand side of $resolved1,<Builtin.Equal>[0, 1, 2, 3]. While processing right hand side of $resolved1,<Builtin.Equal>[0, 1, 2, 3],<<Builtin.Refl>>. Can't find an implementation for DecEq Type.
-
-Deriving.DepTyCheck.Gen.ForOneTypeCon.Impl:1
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
+LOG deptycheck.util.specialisation:10: Builtin.Equal[0(a), 1(b), 2, 3] Declared specialised type DerivedGen.Equal^17761735534830529519.Equal^17761735534830529519: Builtin.Equal {a = Prelude.Basics.Bool} {b = Prelude.Basics.Bool} lam^0 lam^1
+Generated values:
+-----
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+-----
+X1
+-----
+X0 True True Refl
+-----
+X0 True True Refl
+-----
+X0 True True Refl
+-----
+X0 True True Refl
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+-----
+X1
+-----
+X0 False False Refl
+-----
+X0 False False Refl
+-----
+X0 False False Refl
+-----
+X0 False False Refl
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
+-----
+X1
diff --git a/tests/derivation/least-effort/print/specialise/00-1 simple/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/00-1 simple/DerivedGen.idr
new file mode 100644
index 000000000..4ae11f7e7
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-1 simple/DerivedGen.idr	
@@ -0,0 +1,11 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (List Nat)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/00-1 simple/derive.ipkg b/tests/derivation/least-effort/print/specialise/00-1 simple/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-1 simple/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-1 simple/expected b/tests/derivation/least-effort/print/specialise/00-1 simple/expected
new file mode 100644
index 000000000..cdc20151e
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-1 simple/expected	
@@ -0,0 +1,272 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^1 - used final order: [#0, #1]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+              [    var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1"
+                                                          .$ var "{arg:1}"
+                                                          .$ var "{arg:2}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^4779069909474151191.mToP")
+                                          .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/00-1 simple/run b/tests/derivation/least-effort/print/specialise/00-1 simple/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-1 simple/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-2 simple/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/00-2 simple/DerivedGen.idr
new file mode 100644
index 000000000..5b8e9bfe5
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-2 simple/DerivedGen.idr	
@@ -0,0 +1,11 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (List String)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/00-2 simple/derive.ipkg b/tests/derivation/least-effort/print/specialise/00-2 simple/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-2 simple/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-2 simple/expected b/tests/derivation/least-effort/print/specialise/00-2 simple/expected
new file mode 100644
index 000000000..910b6c7bd
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-2 simple/expected	
@@ -0,0 +1,181 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^8984676908526435328.List^8984676908526435328: Prelude.Basics.List String
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^8984676908526435328.List^8984676908526435328[] List^8984676908526435328^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^8984676908526435328.List^8984676908526435328[] List^8984676908526435328^Con^1 - used final order: [#0, #1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]"
+              [    var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>"
+                             [    var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                             [    var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1"
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^8984676908526435328.mToP")
+                                          .$ (var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/00-2 simple/run b/tests/derivation/least-effort/print/specialise/00-2 simple/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-2 simple/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/DerivedGen.idr
new file mode 100644
index 000000000..66d1053ed
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/DerivedGen.idr	
@@ -0,0 +1,11 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (List Nat) (List Nat)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/derive.ipkg b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/expected b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/expected
new file mode 100644
index 000000000..a0e3823f0
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/expected	
@@ -0,0 +1,277 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0, #1]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^1 - used final order: [#0, #1]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+              [    var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1"
+                                                          .$ var "{arg:1}"
+                                                          .$ var "{arg:2}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^4779069909474151191.mToP")
+                                          .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.List^4779069909474151191.mToP")
+                                                  .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^outmost-fuel^"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (var "DerivedGen.MkX" .$ var "{arg:3}" .$ var "{arg:4}"))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/run b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-3 two-same shallow/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-4 two-same deep/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/DerivedGen.idr
new file mode 100644
index 000000000..48eb33847
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data Y = MkY (List Nat)
+
+data X = MkX (List Nat) Y
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/00-4 two-same deep/derive.ipkg b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-4 two-same deep/expected b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/expected
new file mode 100644
index 000000000..c21e6beaf
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/expected	
@@ -0,0 +1,330 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0, #1]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Y[] MkY - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^1 - used final order: [#0, #1]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Y>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.Y"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+              [    var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1"
+                                                          .$ var "{arg:1}"
+                                                          .$ var "{arg:2}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^4779069909474151191.mToP")
+                                          .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.Y>[]" .$ var "^outmost-fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (var "DerivedGen.MkX" .$ var "{arg:3}" .$ var "{arg:4}"))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Y>[]"
+              [    var "<DerivedGen.Y>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkY>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.Y"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkY>>"
+                             [    var "<<DerivedGen.MkY>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkY (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^4779069909474151191.mToP")
+                                          .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkY" .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Y[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkY>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:6}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:6}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/00-4 two-same deep/run b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-4 two-same deep/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-5 two-similar/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/00-5 two-similar/DerivedGen.idr
new file mode 100644
index 000000000..fd4c03830
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-5 two-similar/DerivedGen.idr	
@@ -0,0 +1,11 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (List String) (List Nat)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/00-5 two-similar/derive.ipkg b/tests/derivation/least-effort/print/specialise/00-5 two-similar/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-5 two-similar/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/00-5 two-similar/expected b/tests/derivation/least-effort/print/specialise/00-5 two-similar/expected
new file mode 100644
index 000000000..cd5862556
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-5 two-similar/expected	
@@ -0,0 +1,394 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0, #1]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^8984676908526435328.List^8984676908526435328: Prelude.Basics.List String
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^4779069909474151191.List^4779069909474151191[] List^4779069909474151191^Con^1 - used final order: [#0, #1]
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^8984676908526435328.List^8984676908526435328[] List^8984676908526435328^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^8984676908526435328.List^8984676908526435328[] List^8984676908526435328^Con^1 - used final order: [#0, #1]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]"
+              [    var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                             [    var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1"
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal (Str "DerivedGen.List^4779069909474151191.List^4779069909474151191[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^4779069909474151191.List^4779069909474151191^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]"
+              [    var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>"
+                             [    var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                             [    var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1"
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^8984676908526435328.mToP")
+                                          .$ (var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.List^4779069909474151191.mToP")
+                                                  .$ (var "<DerivedGen.List^4779069909474151191.List^4779069909474151191>[]" .$ var "^outmost-fuel^"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (var "DerivedGen.MkX" .$ var "{arg:4}" .$ var "{arg:5}"))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:6}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:6}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/00-5 two-similar/run b/tests/derivation/least-effort/print/specialise/00-5 two-similar/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/00-5 two-similar/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/DerivedGen.idr
new file mode 100644
index 000000000..1195bfdcb
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n String -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => (n : _) -> Gen MaybeEmpty $ X n
diff --git a/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/derive.ipkg b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/expected b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/expected
new file mode 100644
index 000000000..4b9ef0819
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/expected	
@@ -0,0 +1,208 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> (n : Nat) -> Gen MaybeEmpty (X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0] MkX - used final order: [#1]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^120651999565177027.Vect^120651999565177027: Data.Vect.Vect lam^0 String
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^120651999565177027.Vect^120651999565177027[0(fv^Vect^120651999565177027.Vect^120651999565177027^lam^0)] Vect^120651999565177027^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^120651999565177027.Vect^120651999565177027[0(fv^Vect^120651999565177027.Vect^120651999565177027^lam^0)] Vect^120651999565177027^Con^1 - used final order: [#2 (xs), #1 (x)]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> MkArg MW ExplicitArg (Just "outer^<n>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                   .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "DerivedGen.X" .$ var "{arg:2}")
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[0]"
+              [       var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^120651999565177027.Vect^120651999565177027^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                                  .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                                  .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                             [    var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ bindVar "^cons_fuel^" .$ var "Prelude.Types.Z"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0")
+                             , var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                             [       var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[0]" .$ var "^cons_fuel^" .$ var "len")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027[0(fv^Vect^120651999565177027.Vect^120651999565177027^lam^0)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^120651999565177027.Vect^120651999565177027^lam^0>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^120651999565177027.Vect^120651999565177027[0(fv^Vect^120651999565177027.Vect^120651999565177027^lam^0)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^120651999565177027.Vect^120651999565177027^lam^0>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^120651999565177027.Vect^120651999565177027^lam^0>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0]"
+              [    var "<DerivedGen.X>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:2}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "DerivedGen.X" .$ var "{arg:2}")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "n"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Vect^120651999565177027.mToP")
+                                          .$ (var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[0]" .$ var "^outmost-fuel^" .$ var "n"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:2}>")
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0]" .$ var "^outmost-fuel^" .$ var "outer^<n>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/run b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-1 non-ty imm givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/DerivedGen.idr
new file mode 100644
index 000000000..94e817c4e
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n String -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty (n ** X n)
diff --git a/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/expected b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/expected
new file mode 100644
index 000000000..5edc29981
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/expected	
@@ -0,0 +1,249 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> Gen MaybeEmpty (n : Nat ** X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#1]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^120651999565177027.Vect^120651999565177027: Data.Vect.Vect lam^0 String
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] Vect^120651999565177027^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] Vect^120651999565177027^Con^1 - used final order: [#2 (xs), #1 (x)]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg
+                                             MW
+                                             ExplicitArg
+                                             (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                             (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                           .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                       .=> var "DerivedGen.X" .$ var "{arg:2}"))
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]"
+              [    var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg
+                                                            MW
+                                                            ExplicitArg
+                                                            (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                                            (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                                          .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg
+                                                            MW
+                                                            ExplicitArg
+                                                            (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                                            (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                                          .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                             [    var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0"))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                             [    var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:2}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "the"
+                                          .$ (   var "Gen"
+                                              .$ var "MaybeEmpty"
+                                              .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                          .$ (   var "map"
+                                              .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "invv"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                              .=    var "MkDPair"
+                                                                 .$ var "dph^0"
+                                                                 .$ (var "cast" .@ var "DerivedGen.Vect^120651999565177027.mToP" .$ var "inv")
+                                                            ]
+                                                        })
+                                              .$ (var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]" .$ var "^outmost-fuel^")))
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:3}"
+                                                      .=    var "Prelude.pure"
+                                                         .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                         .$ (   var "Builtin.DPair.MkDPair"
+                                                             .$ implicitTrue
+                                                             .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:3}"))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/run b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-2 non-ty imm gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/DerivedGen.idr
new file mode 100644
index 000000000..c03d90bb0
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/DerivedGen.idr	
@@ -0,0 +1,12 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (Vect n String)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/derive.ipkg b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/expected b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/expected
new file mode 100644
index 000000000..c890309f3
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/expected	
@@ -0,0 +1,237 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#1]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^120651999565177027.Vect^120651999565177027: Data.Vect.Vect lam^0 String
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] Vect^120651999565177027^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] Vect^120651999565177027^Con^1 - used final order: [#2 (xs), #1 (x)]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg
+                                             MW
+                                             ExplicitArg
+                                             (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                             (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                           .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]"
+              [    var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg
+                                                            MW
+                                                            ExplicitArg
+                                                            (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                                            (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                                          .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg
+                                                            MW
+                                                            ExplicitArg
+                                                            (Just "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0")
+                                                            (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027"
+                                                          .$ var "fv^Vect^120651999565177027.Vect^120651999565177027^lam^0"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>"
+                             [    var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0"))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                             [    var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^120651999565177027.Vect^120651999565177027[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^120651999565177027.Vect^120651999565177027^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "the"
+                                          .$ (   var "Gen"
+                                              .$ var "MaybeEmpty"
+                                              .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                          .$ (   var "map"
+                                              .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "invv"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                              .=    var "MkDPair"
+                                                                 .$ var "dph^0"
+                                                                 .$ (var "cast" .@ var "DerivedGen.Vect^120651999565177027.mToP" .$ var "inv")
+                                                            ]
+                                                        })
+                                              .$ (var "<DerivedGen.Vect^120651999565177027.Vect^120651999565177027>[]" .$ var "^outmost-fuel^")))
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:2}"
+                                                      .=    var "Prelude.pure"
+                                                         .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                         .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:2}")
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/run b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/01-3 non-ty imm exist/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/DerivedGen.idr
new file mode 100644
index 000000000..acd2fff78
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/DerivedGen.idr	
@@ -0,0 +1,11 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (List $ Fin n)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/derive.ipkg b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/expected b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/expected
new file mode 100644
index 000000000..b4695fe5d
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/expected	
@@ -0,0 +1,401 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (n), #1]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^1 - used final order: [#1, #2]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                   .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+              [       var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0"
+                                          .! ( "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             , var "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             )))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                  .$ var "^cons_fuel^"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1"
+                                                          .! ("fv^List^12757670414100080037.List^12757670414100080037^lam^0", implicitTrue)
+                                                          .$ var "{arg:1}"
+                                                          .$ var "{arg:2}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:3}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "n") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.List^12757670414100080037.mToP")
+                                                  .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                      .$ var "^outmost-fuel^"
+                                                      .$ var "n"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:4}"))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/run b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-0 non-ty deep exist/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/DerivedGen.idr
new file mode 100644
index 000000000..d0d59ef6b
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Fin
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : List (Fin n) -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty (n ** X n)
diff --git a/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/expected b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/expected
new file mode 100644
index 000000000..91da1cd0f
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/expected	
@@ -0,0 +1,412 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty (n : Nat ** X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (n), #1]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^1 - used final order: [#1, #2]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                   .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat") .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+              [       var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0"
+                                          .! ( "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             , var "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             )))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                  .$ var "^cons_fuel^"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1"
+                                                          .! ("fv^List^12757670414100080037.List^12757670414100080037^lam^0", implicitTrue)
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:4}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "n") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.List^12757670414100080037.mToP")
+                                                  .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                      .$ var "^outmost-fuel^"
+                                                      .$ var "n"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "Builtin.DPair.MkDPair"
+                                                          .$ implicitTrue
+                                                          .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:5}")))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:6}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:6}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/run b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-1 non-ty deep gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/DerivedGen.idr
new file mode 100644
index 000000000..b5bedb1a5
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Fin
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : List (Fin n) -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (n : _) -> Gen MaybeEmpty $ X n
diff --git a/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/derive.ipkg b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/expected b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/expected
new file mode 100644
index 000000000..b2ab3d242
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/expected	
@@ -0,0 +1,308 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (n : Nat) -> Gen MaybeEmpty (X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0] MkX - used final order: [#1]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^1 - used final order: [#1, #2]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<n>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                   .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+              [       var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0"
+                                          .! ( "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             , var "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             )))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                  .$ var "^cons_fuel^"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1"
+                                                          .! ("fv^List^12757670414100080037.List^12757670414100080037^lam^0", implicitTrue)
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:4}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0]"
+              [    var "<DerivedGen.X>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "n"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^12757670414100080037.mToP")
+                                          .$ (var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]" .$ var "^outmost-fuel^" .$ var "n"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0]" .$ var "^outmost-fuel^" .$ var "outer^<n>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/run b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-2 non-ty deep givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-3 two-similar/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/02-3 two-similar/DerivedGen.idr
new file mode 100644
index 000000000..986704fa8
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-3 two-similar/DerivedGen.idr	
@@ -0,0 +1,11 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (List String) (List $ Fin n)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/02-3 two-similar/derive.ipkg b/tests/derivation/least-effort/print/specialise/02-3 two-similar/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-3 two-similar/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/02-3 two-similar/expected b/tests/derivation/least-effort/print/specialise/02-3 two-similar/expected
new file mode 100644
index 000000000..da199b717
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-3 two-similar/expected	
@@ -0,0 +1,521 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#1, #0 (n), #2]
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^8984676908526435328.List^8984676908526435328: Prelude.Basics.List String
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] List^12757670414100080037^Con^1 - used final order: [#1, #2]
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^8984676908526435328.List^8984676908526435328[] List^8984676908526435328^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.List^8984676908526435328.List^8984676908526435328[] List^8984676908526435328^Con^1 - used final order: [#0, #1]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                   .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+              [       var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^List^12757670414100080037.List^12757670414100080037^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0"
+                                          .! ( "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             , var "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                                             )))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                             [       var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^List^12757670414100080037.List^12757670414100080037^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                  .$ var "^cons_fuel^"
+                                                  .$ var "fv^List^12757670414100080037.List^12757670414100080037^lam^0")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1"
+                                                          .! ("fv^List^12757670414100080037.List^12757670414100080037^lam^0", implicitTrue)
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.List^12757670414100080037.List^12757670414100080037[0(fv^List^12757670414100080037.List^12757670414100080037^lam^0)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.List^12757670414100080037.List^12757670414100080037^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^List^12757670414100080037.List^12757670414100080037^lam^0>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:4}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]"
+              [    var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>"
+                             [    var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>"
+                             [    var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ var "^cons_fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1"
+                                                          .$ var "{arg:2}"
+                                                          .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328[] (dry fuel)"))
+                                    .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "DerivedGen.List^8984676908526435328.List^8984676908526435328[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^0>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<DerivedGen.List^8984676908526435328.List^8984676908526435328^Con^1>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.List^8984676908526435328.mToP")
+                                          .$ (var "<DerivedGen.List^8984676908526435328.List^8984676908526435328>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "n") implicitFalse
+                                                  .=>    var ">>="
+                                                      .$ (   var "map"
+                                                          .$ (var "cast" .@ var "DerivedGen.List^12757670414100080037.mToP")
+                                                          .$ (   var "<DerivedGen.List^12757670414100080037.List^12757670414100080037>[0]"
+                                                              .$ var "^outmost-fuel^"
+                                                              .$ var "n"))
+                                                      .$ (    MkArg MW ExplicitArg (Just "{arg:6}") implicitFalse
+                                                          .=>    var "Prelude.pure"
+                                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                              .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:5}" .$ var "{arg:6}")))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:7}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:7}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/02-3 two-similar/run b/tests/derivation/least-effort/print/specialise/02-3 two-similar/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/02-3 two-similar/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/DerivedGen.idr
new file mode 100644
index 000000000..019a56ff2
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/DerivedGen.idr	
@@ -0,0 +1,12 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (Vect n $ Fin n)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/derive.ipkg b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/expected b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/expected
new file mode 100644
index 000000000..730122e59
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/expected	
@@ -0,0 +1,416 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (n), #1]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:1}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "n") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                                  .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                                      .$ var "^outmost-fuel^"
+                                                      .$ var "n"
+                                                      .$ var "n"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:2}"))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/run b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-0 non-ty imm-deep-same exist/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/DerivedGen.idr
new file mode 100644
index 000000000..a13dffd4b
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin n) -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty (n ** X n)
diff --git a/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/expected b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/expected
new file mode 100644
index 000000000..977f330b9
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/expected	
@@ -0,0 +1,427 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty (n : Nat ** X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (n), #1]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat") .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "n") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                                  .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                                      .$ var "^outmost-fuel^"
+                                                      .$ var "n"
+                                                      .$ var "n"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "Builtin.DPair.MkDPair"
+                                                          .$ implicitTrue
+                                                          .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:3}")))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/run b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-1 non-ty imm-deep-same gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/DerivedGen.idr
new file mode 100644
index 000000000..8f0a194a6
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin n) -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (n : _) -> Gen MaybeEmpty $ X n
diff --git a/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/derive.ipkg b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/expected b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/expected
new file mode 100644
index 000000000..56b293ced
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/expected	
@@ -0,0 +1,325 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (n : Nat) -> Gen MaybeEmpty (X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0] MkX - used final order: [#1]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<n>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0]"
+              [    var "<DerivedGen.X>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "n"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                          .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ var "n"
+                                              .$ var "n"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .! ("n", implicitTrue) .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0]" .$ var "^outmost-fuel^" .$ var "outer^<n>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/run b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/03-2 non-ty imm-deep-same givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/DerivedGen.idr
new file mode 100644
index 000000000..b3149077d
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/DerivedGen.idr	
@@ -0,0 +1,12 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X = MkX (Vect n $ Fin m)
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/expected b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/expected
new file mode 100644
index 000000000..ac667e081
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/expected	
@@ -0,0 +1,448 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (m), #2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                              .! ( "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 , var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (   var "<Data.Fin.Fin>[0]"
+                                                             .$ var "^outmost-fuel^"
+                                                             .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:1}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "the"
+                                                  .$ (   var "Gen"
+                                                      .$ var "MaybeEmpty"
+                                                      .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                                  .$ (   var "map"
+                                                      .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                          .=> iCase
+                                                                { sc = var "invv"
+                                                                , ty = implicitFalse
+                                                                , clauses =
+                                                                    [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                                      .=    var "MkDPair"
+                                                                         .$ var "dph^0"
+                                                                         .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP" .$ var "inv")
+                                                                    ]
+                                                                })
+                                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                                          .$ var "^outmost-fuel^"
+                                                          .$ var "m")))
+                                              .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "{lamc:1}"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:2}"
+                                                              .=    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (var "DerivedGen.MkX" .! ("m", implicitTrue) .! ("n", implicitTrue) .$ var "{arg:2}")
+                                                            ]
+                                                        })))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/run b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-0 non-ty imm-deep-diff exist-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/DerivedGen.idr
new file mode 100644
index 000000000..67a3ea1bf
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X m
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (m : _) -> Gen MaybeEmpty $ X m
diff --git a/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/expected b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/expected
new file mode 100644
index 000000000..cb8530f3c
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/expected	
@@ -0,0 +1,355 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (m : Nat) -> Gen MaybeEmpty (X m)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0] MkX - used final order: [#2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<m>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                              .! ( "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 , var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (   var "<Data.Fin.Fin>[0]"
+                                                             .$ var "^outmost-fuel^"
+                                                             .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0]"
+              [    var "<DerivedGen.X>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "m"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "the"
+                                          .$ (   var "Gen"
+                                              .$ var "MaybeEmpty"
+                                              .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                          .$ (   var "map"
+                                              .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "invv"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                              .=    var "MkDPair"
+                                                                 .$ var "dph^0"
+                                                                 .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP" .$ var "inv")
+                                                            ]
+                                                        })
+                                              .$ (var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]" .$ var "^outmost-fuel^" .$ var "m")))
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:3}"
+                                                      .=    var "Prelude.pure"
+                                                         .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                         .$ (var "DerivedGen.MkX" .! ("m", implicitTrue) .! ("n", implicitTrue) .$ var "{arg:3}")
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0]" .$ var "^outmost-fuel^" .$ var "outer^<m>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/run b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-1 non-ty imm-deep-diff exist-givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/DerivedGen.idr
new file mode 100644
index 000000000..930ed914c
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (n : _) -> Gen MaybeEmpty $ X n
diff --git a/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/expected b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/expected
new file mode 100644
index 000000000..1651a59a4
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/expected	
@@ -0,0 +1,421 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (n : Nat) -> Gen MaybeEmpty (X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0] MkX - used final order: [#0 (m), #2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<n>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0]"
+              [    var "<DerivedGen.X>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "DerivedGen.X" .$ var "{arg:1}")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "n"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                                  .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                                      .$ var "^outmost-fuel^"
+                                                      .$ var "n"
+                                                      .$ var "m"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (var "DerivedGen.MkX" .! ("m", implicitTrue) .! ("n", implicitTrue) .$ var "{arg:3}"))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0]" .$ var "^outmost-fuel^" .$ var "outer^<n>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/run b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-2 non-ty imm-deep-diff exist-givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/DerivedGen.idr
new file mode 100644
index 000000000..9ff70b1d9
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X m
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty (m ** X m)
diff --git a/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/expected b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/expected
new file mode 100644
index 000000000..5829177a2
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/expected	
@@ -0,0 +1,462 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty (m : Nat ** X m)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (m), #2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat") .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                              .! ( "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 , var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (   var "<Data.Fin.Fin>[0]"
+                                                             .$ var "^outmost-fuel^"
+                                                             .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "the"
+                                                  .$ (   var "Gen"
+                                                      .$ var "MaybeEmpty"
+                                                      .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                                  .$ (   var "map"
+                                                      .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                          .=> iCase
+                                                                { sc = var "invv"
+                                                                , ty = implicitFalse
+                                                                , clauses =
+                                                                    [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                                      .=    var "MkDPair"
+                                                                         .$ var "dph^0"
+                                                                         .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP" .$ var "inv")
+                                                                    ]
+                                                                })
+                                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                                          .$ var "^outmost-fuel^"
+                                                          .$ var "m")))
+                                              .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "{lamc:1}"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:3}"
+                                                              .=    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.MkX"
+                                                                         .! ("m", implicitTrue)
+                                                                         .! ("n", implicitTrue)
+                                                                         .$ var "{arg:3}"))
+                                                            ]
+                                                        })))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/run b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-3 non-ty imm-deep-diff exist-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/DerivedGen.idr
new file mode 100644
index 000000000..4026f1af3
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X n
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty (n ** X n)
diff --git a/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/expected b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/expected
new file mode 100644
index 000000000..c33b14ea4
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/expected	
@@ -0,0 +1,462 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty (n : Nat ** X n)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (m), #2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat") .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                              .! ( "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 , var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (   var "<Data.Fin.Fin>[0]"
+                                                             .$ var "^outmost-fuel^"
+                                                             .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:1}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "the"
+                                                  .$ (   var "Gen"
+                                                      .$ var "MaybeEmpty"
+                                                      .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                                  .$ (   var "map"
+                                                      .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                          .=> iCase
+                                                                { sc = var "invv"
+                                                                , ty = implicitFalse
+                                                                , clauses =
+                                                                    [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                                      .=    var "MkDPair"
+                                                                         .$ var "dph^0"
+                                                                         .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP" .$ var "inv")
+                                                                    ]
+                                                                })
+                                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                                          .$ var "^outmost-fuel^"
+                                                          .$ var "m")))
+                                              .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "{lamc:1}"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:3}"
+                                                              .=    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.MkX"
+                                                                         .! ("m", implicitTrue)
+                                                                         .! ("n", implicitTrue)
+                                                                         .$ var "{arg:3}"))
+                                                            ]
+                                                        })))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/run b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-4 non-ty imm-deep-diff exist-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/DerivedGen.idr
new file mode 100644
index 000000000..c0cea170f
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty (n ** m ** X n m)
diff --git a/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/expected b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/expected
new file mode 100644
index 000000000..f22357575
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/expected	
@@ -0,0 +1,471 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty (n : Nat ** (m : Nat ** X n m))
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0 (m), #2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                       .=>    var "Builtin.DPair.DPair"
+                                           .$ var "Prelude.Types.Nat"
+                                           .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                               .=> var "DerivedGen.X" .$ var "{arg:1}" .$ var "{arg:2}")))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                              .! ( "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 , var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (   var "<Data.Fin.Fin>[0]"
+                                                             .$ var "^outmost-fuel^"
+                                                             .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:3}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                                      .=>    var "Builtin.DPair.DPair"
+                                                          .$ var "Prelude.Types.Nat"
+                                                          .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                                              .=> var "DerivedGen.X" .$ var "{arg:1}" .$ var "{arg:2}")))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "the"
+                                                  .$ (   var "Gen"
+                                                      .$ var "MaybeEmpty"
+                                                      .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                                  .$ (   var "map"
+                                                      .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                          .=> iCase
+                                                                { sc = var "invv"
+                                                                , ty = implicitFalse
+                                                                , clauses =
+                                                                    [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                                      .=    var "MkDPair"
+                                                                         .$ var "dph^0"
+                                                                         .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP" .$ var "inv")
+                                                                    ]
+                                                                })
+                                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                                          .$ var "^outmost-fuel^"
+                                                          .$ var "m")))
+                                              .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "{lamc:1}"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:4}"
+                                                              .=    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "Builtin.DPair.MkDPair"
+                                                                         .$ implicitTrue
+                                                                         .$ (   var "DerivedGen.MkX"
+                                                                             .! ("m", implicitTrue)
+                                                                             .! ("n", implicitTrue)
+                                                                             .$ var "{arg:4}")))
+                                                            ]
+                                                        })))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/run b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-5 non-ty imm-deep-diff gend-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/DerivedGen.idr
new file mode 100644
index 000000000..03058760b
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (n, m : _) -> Gen MaybeEmpty $ X n m
diff --git a/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/expected b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/expected
new file mode 100644
index 000000000..4fb124156
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/expected	
@@ -0,0 +1,330 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (n : Nat) -> (m : Nat) -> Gen MaybeEmpty (X n m)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0, 1] MkX - used final order: [#2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<n>") implicitTrue
+.=> MkArg MW ExplicitArg (Just "outer^<m>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (var "DerivedGen.X" .$ var "{arg:1}" .$ var "{arg:2}")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:3}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0, 1]"
+              [    var "<DerivedGen.X>[0, 1]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>" .$ bindVar "inter^<{arg:2}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "DerivedGen.X" .$ var "{arg:1}" .$ var "{arg:2}")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "n" .$ bindVar "m"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                          .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ var "n"
+                                              .$ var "m"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .! ("m", implicitTrue) .! ("n", implicitTrue) .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0, 1] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>" .$ var "inter^<{arg:2}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0, 1]" .$ var "^outmost-fuel^" .$ var "outer^<n>" .$ var "outer^<m>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/run b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-6 non-ty imm-deep-diff givn-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/DerivedGen.idr
new file mode 100644
index 000000000..c522c71f0
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (n : _) -> Gen MaybeEmpty (m ** X n m)
diff --git a/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/expected b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/expected
new file mode 100644
index 000000000..e88079136
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/expected	
@@ -0,0 +1,431 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (n : Nat) -> Gen MaybeEmpty (m : Nat ** X n m)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[0] MkX - used final order: [#0 (m), #2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<n>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                       .=> var "DerivedGen.X" .$ var "{arg:1}" .$ var "{arg:2}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:3}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[0]"
+              [    var "<DerivedGen.X>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:1}" .$ var "{arg:2}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "n"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (   var "map"
+                                                  .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                                  .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                                      .$ var "^outmost-fuel^"
+                                                      .$ var "n"
+                                                      .$ var "m"))
+                                              .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "Builtin.DPair.MkDPair"
+                                                          .$ implicitTrue
+                                                          .$ (var "DerivedGen.MkX" .! ("m", implicitTrue) .! ("n", implicitTrue) .$ var "{arg:4}")))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[0] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[0]" .$ var "^outmost-fuel^" .$ var "outer^<n>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/run b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-7 non-ty imm-deep-diff givn-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/DerivedGen.idr
new file mode 100644
index 000000000..5ebc3b123
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (m : _) -> Gen MaybeEmpty (n ** X n m)
diff --git a/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/derive.ipkg b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/expected b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/expected
new file mode 100644
index 000000000..7cef7a7a5
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/expected	
@@ -0,0 +1,365 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (m : Nat) -> Gen MaybeEmpty (n : Nat ** X n m)
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[1] MkX - used final order: [#2]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<m>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                       .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                           .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ var "Prelude.Types.Nat"
+                                   .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                       .=> var "DerivedGen.X" .$ var "{arg:2}" .$ var "{arg:1}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                                      .=>    var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "Builtin.DPair.MkDPair"
+                                          .$ implicitTrue
+                                          .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                              .! ( "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 , var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                                                 ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "len" .$ bindVar "xs"
+                                                      .=    var ">>="
+                                                         .$ (   var "<Data.Fin.Fin>[0]"
+                                                             .$ var "^outmost-fuel^"
+                                                             .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                                         .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                                         .! ("len", implicitTrue)
+                                                                         .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                                         .$ var "x"
+                                                                         .$ var "xs")))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:3}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[1]"
+              [    var "<DerivedGen.X>[1]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ var "Prelude.Types.Nat"
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "Prelude.Types.Nat")
+                                                      .=> var "DerivedGen.X" .$ var "{arg:2}" .$ var "{arg:1}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^" .$ bindVar "m"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "the"
+                                          .$ (   var "Gen"
+                                              .$ var "MaybeEmpty"
+                                              .$ (var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse)))
+                                          .$ (   var "map"
+                                              .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "invv"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv"
+                                                              .=    var "MkDPair"
+                                                                 .$ var "dph^0"
+                                                                 .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP" .$ var "inv")
+                                                            ]
+                                                        })
+                                              .$ (var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[1]" .$ var "^outmost-fuel^" .$ var "m")))
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "n" .$ bindVar "{arg:4}"
+                                                      .=    var "Prelude.pure"
+                                                         .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                         .$ (   var "Builtin.DPair.MkDPair"
+                                                             .$ implicitTrue
+                                                             .$ (var "DerivedGen.MkX" .! ("m", implicitTrue) .! ("n", implicitTrue) .$ var "{arg:4}"))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[1] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[1]" .$ var "^outmost-fuel^" .$ var "outer^<m>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/run b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/04-8 non-ty imm-deep-diff givn-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/DerivedGen.idr
new file mode 100644
index 000000000..2b0caacab
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/DerivedGen.idr	
@@ -0,0 +1,13 @@
+module DerivedGen
+
+import Data.Vect
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data X : Type where
+  MkX : Vect n (Fin n) -> Either (n `LT` m) (m `LT` n) => X
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/derive.ipkg b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/expected b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/expected
new file mode 100644
index 000000000..3c0149859
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/expected	
@@ -0,0 +1,703 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#1 (n), #0 (m), #3, #2]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^6814960928365568963.Either^6814960928365568963: Prelude.Types.Either (Data.Nat.LTE lam^0 lam^1) (Data.Nat.LTE lam^2 lam^3)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] Vect^1863907217212445550^Con^1 - used final order: [#3 (xs), #2 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^6814960928365568963.Either^6814960928365568963[0(fv^Either^6814960928365568963.Either^6814960928365568963^lam^0), 1(fv^Either^6814960928365568963.Either^6814960928365568963^lam^1), 2(fv^Either^6814960928365568963.Either^6814960928365568963^lam^2), 3(fv^Either^6814960928365568963.Either^6814960928365568963^lam^3)] Either^6814960928365568963^Con^0 - used final order: [#4 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^6814960928365568963.Either^6814960928365568963[0(fv^Either^6814960928365568963.Either^6814960928365568963^lam^0), 1(fv^Either^6814960928365568963.Either^6814960928365568963^lam^1), 2(fv^Either^6814960928365568963.Either^6814960928365568963^lam^2), 3(fv^Either^6814960928365568963.Either^6814960928365568963^lam^3)] Either^6814960928365568963^Con^1 - used final order: [#4 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Nat.LTE[0(n), 1(m)] LTEZero - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Nat.LTE[0(n), 1(m)] LTESucc - used final order: [#2]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^6814960928365568963.Either^6814960928365568963>[0, 1, 2, 3]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Either^6814960928365568963.Either^6814960928365568963"
+                                   .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                   .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                   .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                   .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                   .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Nat.LTE>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "m") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Nat.LTE" .$ var "n" .$ var "m")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^6814960928365568963.Either^6814960928365568963>[0, 1, 2, 3]"
+              [       var "<DerivedGen.Either^6814960928365568963.Either^6814960928365568963>[0, 1, 2, 3]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^0>"
+                   .$ bindVar "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^1>"
+                   .$ bindVar "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^2>"
+                   .$ bindVar "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^3>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^6814960928365568963.Either^6814960928365568963"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^6814960928365568963.Either^6814960928365568963"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                                  .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^0>>"
+                             [       var "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<Data.Nat.LTE>[0, 1]"
+                                          .$ var "^outmost-fuel^"
+                                          .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                          .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^0"
+                                                  .! ("fv^Either^6814960928365568963.Either^6814960928365568963^lam^0", implicitTrue)
+                                                  .! ("fv^Either^6814960928365568963.Either^6814960928365568963^lam^1", implicitTrue)
+                                                  .! ( "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                                     , var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                                     )
+                                                  .! ( "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3"
+                                                     , var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3"
+                                                     )
+                                                  .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^1>>"
+                             [       var "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                  .$ bindVar "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<Data.Nat.LTE>[0, 1]"
+                                          .$ var "^outmost-fuel^"
+                                          .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^2"
+                                          .$ var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^3")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^1"
+                                                  .! ( "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                                     , var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^0"
+                                                     )
+                                                  .! ( "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                                     , var "fv^Either^6814960928365568963.Either^6814960928365568963^lam^1"
+                                                     )
+                                                  .! ("fv^Either^6814960928365568963.Either^6814960928365568963^lam^2", implicitTrue)
+                                                  .! ("fv^Either^6814960928365568963.Either^6814960928365568963^lam^3", implicitTrue)
+                                                  .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (   var "fromString"
+                             .$ primVal
+                                  (Str
+                                     "DerivedGen.Either^6814960928365568963.Either^6814960928365568963[0(fv^Either^6814960928365568963.Either^6814960928365568963^lam^0), 1(fv^Either^6814960928365568963.Either^6814960928365568963^lam^1), 2(fv^Either^6814960928365568963.Either^6814960928365568963^lam^2), 3(fv^Either^6814960928365568963.Either^6814960928365568963^lam^3)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (   var "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^0>>"
+                                     .$ var "^fuel_arg^"
+                                     .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^0>"
+                                     .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^1>"
+                                     .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^2>"
+                                     .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^3>")
+                                 .$ (   var "::"
+                                     .$ (   var "<<DerivedGen.Either^6814960928365568963.Either^6814960928365568963^Con^1>>"
+                                         .$ var "^fuel_arg^"
+                                         .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^0>"
+                                         .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^1>"
+                                         .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^2>"
+                                         .$ var "inter^<fv^Either^6814960928365568963.Either^6814960928365568963^lam^3>")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+              [       var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                   .$ bindVar "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0"
+                                                  .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ var "Prelude.Types.Z"
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0"
+                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                             [       var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                                  .$ bindVar "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                          .$ var "^cons_fuel^"
+                                          .$ var "len"
+                                          .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1")
+                                              .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .! ("fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550[0(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0), 1(fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                    .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^0>"
+                                                        .$ var "inter^<fv^Vect^1863907217212445550.Vect^1863907217212445550^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:1}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Nat.LTE>[0, 1]"
+              [    var "<Data.Nat.LTE>[0, 1]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>" .$ bindVar "inter^<m>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Nat.LTEZero>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "m") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "Data.Nat.LTE" .$ var "n" .$ var "m")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Nat.LTESucc>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "m") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (var "Data.Nat.LTE" .$ var "n" .$ var "m")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Nat.LTEZero>>"
+                             [    var "<<Data.Nat.LTEZero>>" .$ bindVar "^cons_fuel^" .$ var "Prelude.Types.Z" .$ bindVar "right"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Nat.LTEZero (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ (var "Data.Nat.LTEZero" .! ("right", var "right")))
+                             , var "<<Data.Nat.LTEZero>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Nat.LTESucc>>"
+                             [       var "<<Data.Nat.LTESucc>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "left")
+                                  .$ (var "Prelude.Types.S" .$ bindVar "right")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Nat.LTESucc (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Nat.LTE>[0, 1]" .$ var "^cons_fuel^" .$ var "left" .$ var "right")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Nat.LTESucc" .! ("right", implicitTrue) .! ("left", implicitTrue) .$ var "{arg:2}")))
+                             , var "<<Data.Nat.LTESucc>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Nat.LTE[0(n), 1(m)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (   var "Builtin.MkPair"
+                                     .$ var "Data.Nat1.one"
+                                     .$ (var "<<Data.Nat.LTEZero>>" .$ var "^fuel_arg^" .$ var "inter^<n>" .$ var "inter^<m>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Nat.LTESucc>>" .$ var "^fuel_arg^" .$ var "inter^<n>" .$ var "inter^<m>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "n") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                              .$ (    MkArg MW ExplicitArg (Just "m") implicitFalse
+                                                  .=>    var ">>="
+                                                      .$ (   var "map"
+                                                          .$ (var "cast" .@ var "DerivedGen.Either^6814960928365568963.mToP")
+                                                          .$ (   var "<DerivedGen.Either^6814960928365568963.Either^6814960928365568963>[0, 1, 2, 3]"
+                                                              .$ var "^outmost-fuel^"
+                                                              .$ (var "Prelude.Types.S" .$ var "n")
+                                                              .$ var "m"
+                                                              .$ (var "Prelude.Types.S" .$ var "m")
+                                                              .$ var "n"))
+                                                      .$ (    MkArg MW ExplicitArg (Just "{conArg:1}") implicitFalse
+                                                          .=>    var ">>="
+                                                              .$ (   var "map"
+                                                                  .$ (var "cast" .@ var "DerivedGen.Vect^1863907217212445550.mToP")
+                                                                  .$ (   var "<DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550>[0, 1]"
+                                                                      .$ var "^outmost-fuel^"
+                                                                      .$ var "n"
+                                                                      .$ var "n"))
+                                                              .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                                                  .=>    var "Prelude.pure"
+                                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                      .$ (   var "DerivedGen.MkX"
+                                                                          .! ("m", implicitTrue)
+                                                                          .! ("n", implicitTrue)
+                                                                          .$ var "{arg:3}"
+                                                                          .@ var "{conArg:1}"))))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/run b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/05-0 non-ty complex exist-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-0 ty shallow/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/DerivedGen.idr
new file mode 100644
index 000000000..27cc64df1
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/DerivedGen.idr	
@@ -0,0 +1,15 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data Y : Type -> Type where
+  MkY : Either Nat a -> Y a
+
+data X : Type where
+  MkX : Either Nat (Y Nat) -> X
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/06-0 ty shallow/derive.ipkg b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-0 ty shallow/expected b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/expected
new file mode 100644
index 000000000..220e438e6
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/expected	
@@ -0,0 +1,413 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^4289176107705670177.Either^4289176107705670177: Prelude.Types.Either Prelude.Types.Nat (DerivedGen.Y Prelude.Types.Nat)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^4289176107705670177.Either^4289176107705670177[] Either^4289176107705670177^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^4289176107705670177.Either^4289176107705670177[] Either^4289176107705670177^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0] Declared specialised type DerivedGen.Y^11712255676025100806.Y^11712255676025100806: DerivedGen.Y Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Y^11712255676025100806.Y^11712255676025100806[] Y^11712255676025100806^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^1 - used final order: [#0 (x)]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^4289176107705670177.Either^4289176107705670177>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^4289176107705670177.Either^4289176107705670177"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Y^11712255676025100806.Y^11712255676025100806"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+              [    var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^4289176107705670177.Either^4289176107705670177>[]"
+              [    var "<DerivedGen.Either^4289176107705670177.Either^4289176107705670177>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^4289176107705670177.Either^4289176107705670177"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^4289176107705670177.Either^4289176107705670177"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^0>>"
+                             [    var "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^1>>"
+                             [    var "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Y^11712255676025100806.mToP")
+                                          .$ (var "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^4289176107705670177.Either^4289176107705670177[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^4289176107705670177.Either^4289176107705670177^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^4289176107705670177.mToP")
+                                          .$ (var "<DerivedGen.Either^4289176107705670177.Either^4289176107705670177>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:1}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]"
+              [    var "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Y^11712255676025100806.Y^11712255676025100806"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>"
+                             [    var "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^13682636983817606971.mToP")
+                                          .$ (var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0" .$ var "{arg:2}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^11712255676025100806.Y^11712255676025100806[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/06-0 ty shallow/run b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-0 ty shallow/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-1 ty deeper/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/DerivedGen.idr
new file mode 100644
index 000000000..e3b606af2
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/DerivedGen.idr	
@@ -0,0 +1,15 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data Y : Type -> Type where
+  MkY : Either Nat a -> Y a
+
+data X : Type where
+  MkX : Either Nat (Y $ Either (Fin 5) String) -> X
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/06-1 ty deeper/derive.ipkg b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-1 ty deeper/expected b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/expected
new file mode 100644
index 000000000..4155ded63
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/expected	
@@ -0,0 +1,705 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> {auto conArg : ((arg : Fuel) -> Gen MaybeEmpty String)} -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^17089122808763292221.Either^17089122808763292221: Prelude.Types.Either Prelude.Types.Nat (DerivedGen.Y (Prelude.Types.Either (Data.Fin.Fin lam^0) String))
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^17089122808763292221.Either^17089122808763292221[0(fv^Either^17089122808763292221.Either^17089122808763292221^lam^0)] Either^17089122808763292221^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^17089122808763292221.Either^17089122808763292221[0(fv^Either^17089122808763292221.Either^17089122808763292221^lam^0)] Either^17089122808763292221^Con^1 - used final order: [#1 (x)]
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0] Declared specialised type DerivedGen.Y^7167106520753982886.Y^7167106520753982886: DerivedGen.Y (Prelude.Types.Either (Data.Fin.Fin lam^0) String)
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Y^7167106520753982886.Y^7167106520753982886[0(fv^Y^7167106520753982886.Y^7167106520753982886^lam^0)] Y^7167106520753982886^Con^0 - used final order: [#1]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^5595291053177582713.Either^5595291053177582713: Prelude.Types.Either Prelude.Types.Nat (Prelude.Types.Either (Data.Fin.Fin lam^0) String)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^5595291053177582713.Either^5595291053177582713[0(fv^Either^5595291053177582713.Either^5595291053177582713^lam^0)] Either^5595291053177582713^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^5595291053177582713.Either^5595291053177582713[0(fv^Either^5595291053177582713.Either^5595291053177582713^lam^0)] Either^5595291053177582713^Con^1 - used final order: [#1 (x)]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13748098436294604892.Either^13748098436294604892: Prelude.Types.Either (Data.Fin.Fin lam^0) String
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13748098436294604892.Either^13748098436294604892[0(fv^Either^13748098436294604892.Either^13748098436294604892^lam^0)] Either^13748098436294604892^Con^0 - used final order: [#1 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13748098436294604892.Either^13748098436294604892[0(fv^Either^13748098436294604892.Either^13748098436294604892^lam^0)] Either^13748098436294604892^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FZ - used final order: []
+LOG deptycheck.derive.least-effort:7: Data.Fin.Fin[0(n)] FS - used final order: [#1]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg
+      MW
+      AutoImplicit
+      (Just "external^<^prim^.String>[]")
+      (    MkArg MW ExplicitArg (Just "{arg:1}") (var "Data.Fuel.Fuel")
+       .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ primVal (PrT StringType))
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^13748098436294604892.Either^13748098436294604892>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Either^13748098436294604892.Either^13748098436294604892"
+                                   .$ var "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^17089122808763292221.Either^17089122808763292221>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Either^17089122808763292221.Either^17089122808763292221"
+                                   .$ var "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^5595291053177582713.Either^5595291053177582713>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Either^5595291053177582713.Either^5595291053177582713"
+                                   .$ var "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Y^7167106520753982886.Y^7167106520753982886>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Y^7167106520753982886.Y^7167106520753982886^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (var "DerivedGen.Y^7167106520753982886.Y^7167106520753982886" .$ var "fv^Y^7167106520753982886.Y^7167106520753982886^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Data.Fin.Fin>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type = mkTy {name = "weight^Prelude.Types.Nat", type = MkArg MW ExplicitArg Nothing (var "Prelude.Types.Nat") .-> var "Data.Nat1.Nat1"}
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^13748098436294604892.Either^13748098436294604892>[0]"
+              [       var "<DerivedGen.Either^13748098436294604892.Either^13748098436294604892>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Either^13748098436294604892.Either^13748098436294604892^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^13748098436294604892.Either^13748098436294604892"
+                                                  .$ var "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^13748098436294604892.Either^13748098436294604892"
+                                                  .$ var "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^0>>"
+                             [       var "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^outmost-fuel^" .$ var "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^0"
+                                                  .! ("fv^Either^13748098436294604892.Either^13748098436294604892^lam^0", implicitTrue)
+                                                  .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^1>>"
+                             [       var "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "external^<^prim^.String>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^1"
+                                                  .$ var "x"
+                                                  .! ( "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0"
+                                                     , var "fv^Either^13748098436294604892.Either^13748098436294604892^lam^0"
+                                                     ))))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (   var "fromString"
+                             .$ primVal
+                                  (Str
+                                     "DerivedGen.Either^13748098436294604892.Either^13748098436294604892[0(fv^Either^13748098436294604892.Either^13748098436294604892^lam^0)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (   var "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^0>>"
+                                     .$ var "^fuel_arg^"
+                                     .$ var "inter^<fv^Either^13748098436294604892.Either^13748098436294604892^lam^0>")
+                                 .$ (   var "::"
+                                     .$ (   var "<<DerivedGen.Either^13748098436294604892.Either^13748098436294604892^Con^1>>"
+                                         .$ var "^fuel_arg^"
+                                         .$ var "inter^<fv^Either^13748098436294604892.Either^13748098436294604892^lam^0>")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^17089122808763292221.Either^17089122808763292221>[0]"
+              [       var "<DerivedGen.Either^17089122808763292221.Either^17089122808763292221>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Either^17089122808763292221.Either^17089122808763292221^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^17089122808763292221.Either^17089122808763292221"
+                                                  .$ var "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^17089122808763292221.Either^17089122808763292221"
+                                                  .$ var "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^0>>"
+                             [       var "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^0"
+                                                  .$ var "x"
+                                                  .! ( "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0"
+                                                     , var "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0"
+                                                     ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^1>>"
+                             [       var "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Y^7167106520753982886.mToP")
+                                          .$ (   var "<DerivedGen.Y^7167106520753982886.Y^7167106520753982886>[0]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ var "fv^Either^17089122808763292221.Either^17089122808763292221^lam^0"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^1"
+                                                  .! ("fv^Either^17089122808763292221.Either^17089122808763292221^lam^0", implicitTrue)
+                                                  .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (   var "fromString"
+                             .$ primVal
+                                  (Str
+                                     "DerivedGen.Either^17089122808763292221.Either^17089122808763292221[0(fv^Either^17089122808763292221.Either^17089122808763292221^lam^0)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (   var "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^0>>"
+                                     .$ var "^fuel_arg^"
+                                     .$ var "inter^<fv^Either^17089122808763292221.Either^17089122808763292221^lam^0>")
+                                 .$ (   var "::"
+                                     .$ (   var "<<DerivedGen.Either^17089122808763292221.Either^17089122808763292221^Con^1>>"
+                                         .$ var "^fuel_arg^"
+                                         .$ var "inter^<fv^Either^17089122808763292221.Either^17089122808763292221^lam^0>")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^5595291053177582713.Either^5595291053177582713>[0]"
+              [       var "<DerivedGen.Either^5595291053177582713.Either^5595291053177582713>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Either^5595291053177582713.Either^5595291053177582713^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^5595291053177582713.Either^5595291053177582713"
+                                                  .$ var "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Either^5595291053177582713.Either^5595291053177582713"
+                                                  .$ var "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^0>>"
+                             [       var "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^0"
+                                                  .$ var "x"
+                                                  .! ( "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0"
+                                                     , var "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0"
+                                                     ))))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^1>>"
+                             [       var "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^13748098436294604892.mToP")
+                                          .$ (   var "<DerivedGen.Either^13748098436294604892.Either^13748098436294604892>[0]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ var "fv^Either^5595291053177582713.Either^5595291053177582713^lam^0"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^1"
+                                                  .! ("fv^Either^5595291053177582713.Either^5595291053177582713^lam^0", implicitTrue)
+                                                  .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (   var "fromString"
+                             .$ primVal
+                                  (Str
+                                     "DerivedGen.Either^5595291053177582713.Either^5595291053177582713[0(fv^Either^5595291053177582713.Either^5595291053177582713^lam^0)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (   var "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^0>>"
+                                     .$ var "^fuel_arg^"
+                                     .$ var "inter^<fv^Either^5595291053177582713.Either^5595291053177582713^lam^0>")
+                                 .$ (   var "::"
+                                     .$ (   var "<<DerivedGen.Either^5595291053177582713.Either^5595291053177582713^Con^1>>"
+                                         .$ var "^fuel_arg^"
+                                         .$ var "inter^<fv^Either^5595291053177582713.Either^5595291053177582713^lam^0>")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Y^7167106520753982886.Y^7167106520753982886>[0]"
+              [       var "<DerivedGen.Y^7167106520753982886.Y^7167106520753982886>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Y^7167106520753982886.Y^7167106520753982886^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Y^7167106520753982886.Y^7167106520753982886^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Y^7167106520753982886.Y^7167106520753982886^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Y^7167106520753982886.Y^7167106520753982886"
+                                                  .$ var "fv^Y^7167106520753982886.Y^7167106520753982886^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Y^7167106520753982886.Y^7167106520753982886^Con^0>>"
+                             [       var "<<DerivedGen.Y^7167106520753982886.Y^7167106520753982886^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "fv^Y^7167106520753982886.Y^7167106520753982886^lam^0"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^7167106520753982886.Y^7167106520753982886^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^5595291053177582713.mToP")
+                                          .$ (   var "<DerivedGen.Either^5595291053177582713.Either^5595291053177582713>[0]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ var "fv^Y^7167106520753982886.Y^7167106520753982886^lam^0"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Y^7167106520753982886.Y^7167106520753982886^Con^0"
+                                                  .! ("fv^Y^7167106520753982886.Y^7167106520753982886^lam^0", implicitTrue)
+                                                  .$ var "{arg:2}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (   var "fromString"
+                             .$ primVal
+                                  (Str
+                                     "DerivedGen.Y^7167106520753982886.Y^7167106520753982886[0(fv^Y^7167106520753982886.Y^7167106520753982886^lam^0)] (non-spending)"))
+                         .$ (   var "<<DerivedGen.Y^7167106520753982886.Y^7167106520753982886^Con^0>>"
+                             .$ var "^fuel_arg^"
+                             .$ var "inter^<fv^Y^7167106520753982886.Y^7167106520753982886^lam^0>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Data.Fin.Fin>[0]"
+              [    var "<Data.Fin.Fin>[0]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<n>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FZ>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Data.Fin.FS>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "n") (var "Prelude.Types.Nat")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ (var "Data.Fin.Fin" .$ var "n")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FZ>>"
+                             [    var "<<Data.Fin.FZ>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FZ (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ (var "Data.Fin.FZ" .! ("k", var "k")))
+                             , var "<<Data.Fin.FZ>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Data.Fin.FS>>"
+                             [    var "<<Data.Fin.FS>>" .$ bindVar "^cons_fuel^" .$ (var "Prelude.Types.S" .$ bindVar "k")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Data.Fin.FS (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Data.Fin.Fin>[0]" .$ var "^cons_fuel^" .$ var "k")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Data.Fin.FS" .! ("k", implicitTrue) .$ var "{arg:3}")))
+                             , var "<<Data.Fin.FS>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Data.Fin.Fin[0(n)] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.frequency"
+                             .$ (   var "::"
+                                 .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Data.Fin.FZ>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                 .$ (   var "::"
+                                     .$ (   var "Builtin.MkPair"
+                                         .$ (var "weight^Prelude.Types.Nat" .$ var "inter^<n>")
+                                         .$ (var "<<Data.Fin.FS>>" .$ var "^fuel_arg^" .$ var "inter^<n>"))
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^17089122808763292221.mToP")
+                                          .$ (   var "<DerivedGen.Either^17089122808763292221.Either^17089122808763292221>[0]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ (   var "Prelude.Types.S"
+                                                  .$ (   var "Prelude.Types.S"
+                                                      .$ (var "Prelude.Types.S" .$ (var "Prelude.Types.S" .$ (var "Prelude.Types.S" .$ var "Prelude.Types.Z")))))))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:5}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:5}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "weight^Prelude.Types.Nat"
+              [ var "weight^Prelude.Types.Nat" .$ var "Prelude.Types.Z" .= var "Data.Nat1.one"
+              , var "weight^Prelude.Types.Nat" .$ (var "Prelude.Types.S" .$ bindVar "arg^0") .= var "succ" .$ (var "weight^Prelude.Types.Nat" .$ var "arg^0")
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/06-1 ty deeper/run b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-1 ty deeper/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-2 ty deep/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/06-2 ty deep/DerivedGen.idr
new file mode 100644
index 000000000..1da9baee5
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-2 ty deep/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data Z : Type -> Type where
+  MkZ : Either Nat a -> Z a
+
+data Y : Type -> Type where
+  MkY : Either (Z a) a -> Y a
+
+data X : Type where
+  MkX : Y Nat -> X
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/06-2 ty deep/derive.ipkg b/tests/derivation/least-effort/print/specialise/06-2 ty deep/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-2 ty deep/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-2 ty deep/expected b/tests/derivation/least-effort/print/specialise/06-2 ty deep/expected
new file mode 100644
index 000000000..f7d2d235b
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-2 ty deep/expected	
@@ -0,0 +1,473 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0] Declared specialised type DerivedGen.Y^11712255676025100806.Y^11712255676025100806: DerivedGen.Y Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Y^11712255676025100806.Y^11712255676025100806[] Y^11712255676025100806^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^8529713418737914198.Either^8529713418737914198: Prelude.Types.Either (DerivedGen.Z Prelude.Types.Nat) Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^8529713418737914198.Either^8529713418737914198[] Either^8529713418737914198^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^4772972569107533783.Z^4772972569107533783: DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^8529713418737914198.Either^8529713418737914198[] Either^8529713418737914198^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Z^4772972569107533783.Z^4772972569107533783[] Z^4772972569107533783^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^1 - used final order: [#0 (x)]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Y^11712255676025100806.Y^11712255676025100806"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+              [    var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]"
+              [    var "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>"
+                             [    var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Z^4772972569107533783.mToP")
+                                          .$ (var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>"
+                             [    var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^8529713418737914198.Either^8529713418737914198[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Y^11712255676025100806.mToP")
+                                          .$ (var "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:1}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]"
+              [    var "<DerivedGen.Y^11712255676025100806.Y^11712255676025100806>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Y^11712255676025100806.Y^11712255676025100806"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>"
+                             [    var "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^8529713418737914198.mToP")
+                                          .$ (var "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0" .$ var "{arg:2}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^11712255676025100806.Y^11712255676025100806[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Y^11712255676025100806.Y^11712255676025100806^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]"
+              [    var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>"
+                             [    var "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^13682636983817606971.mToP")
+                                          .$ (var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^4772972569107533783.Z^4772972569107533783[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/06-2 ty deep/run b/tests/derivation/least-effort/print/specialise/06-2 ty deep/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-2 ty deep/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/DerivedGen.idr
new file mode 100644
index 000000000..8fe83911a
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data Z : Type -> Type where
+  MkZ : Either Nat a -> Z a
+
+data Y : (Type -> Type) -> Type -> Type where
+  MkY : Either (f a) a -> Y f a
+
+data X : Type where
+  MkX : Y Z Nat -> X
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/derive.ipkg b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/expected b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/expected
new file mode 100644
index 000000000..e134c780e
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/expected	
@@ -0,0 +1,473 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0, 1] Declared specialised type DerivedGen.Y^6741950274054397085.Y^6741950274054397085: DerivedGen.Y DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Y^6741950274054397085.Y^6741950274054397085[] Y^6741950274054397085^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^8529713418737914198.Either^8529713418737914198: Prelude.Types.Either (DerivedGen.Z Prelude.Types.Nat) Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^8529713418737914198.Either^8529713418737914198[] Either^8529713418737914198^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^4772972569107533783.Z^4772972569107533783: DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^8529713418737914198.Either^8529713418737914198[] Either^8529713418737914198^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Z^4772972569107533783.Z^4772972569107533783[] Z^4772972569107533783^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^1 - used final order: [#0 (x)]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Y^6741950274054397085.Y^6741950274054397085"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+              [    var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]"
+              [    var "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>"
+                             [    var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Z^4772972569107533783.mToP")
+                                          .$ (var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>"
+                             [    var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^8529713418737914198.Either^8529713418737914198[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^8529713418737914198.Either^8529713418737914198^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Y^6741950274054397085.mToP")
+                                          .$ (var "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:1}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]"
+              [    var "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Y^6741950274054397085.Y^6741950274054397085"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>"
+                             [    var "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^8529713418737914198.mToP")
+                                          .$ (var "<DerivedGen.Either^8529713418737914198.Either^8529713418737914198>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0" .$ var "{arg:2}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^6741950274054397085.Y^6741950274054397085[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]"
+              [    var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>"
+                             [    var "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^13682636983817606971.mToP")
+                                          .$ (var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^4772972569107533783.Z^4772972569107533783[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/run b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-3 ty deep hkd/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/DerivedGen.idr
new file mode 100644
index 000000000..762b09c82
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+data Z : Type -> Type where
+  MkZ : Either Nat a -> Z a
+
+data Y : (Type -> Type) -> Type -> Type where
+  MkY : Either (f a) (f $ f a) -> Y f a
+
+data X : Type where
+  MkX : Y Z Nat -> X
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty X
diff --git a/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/derive.ipkg b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/expected b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/expected
new file mode 100644
index 000000000..e7bf6e3df
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/expected	
@@ -0,0 +1,630 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty X
+LOG deptycheck.derive.least-effort:7: DerivedGen.X[] MkX - used final order: [#0]
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0, 1] Declared specialised type DerivedGen.Y^6741950274054397085.Y^6741950274054397085: DerivedGen.Y DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Y^6741950274054397085.Y^6741950274054397085[] Y^6741950274054397085^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^70731854558853028.Either^70731854558853028: Prelude.Types.Either (DerivedGen.Z Prelude.Types.Nat) (DerivedGen.Z (DerivedGen.Z Prelude.Types.Nat))
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^70731854558853028.Either^70731854558853028[] Either^70731854558853028^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^4772972569107533783.Z^4772972569107533783: DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^70731854558853028.Either^70731854558853028[] Either^70731854558853028^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^15549736185298716768.Z^15549736185298716768: DerivedGen.Z (DerivedGen.Z Prelude.Types.Nat)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Z^15549736185298716768.Z^15549736185298716768[] Z^15549736185298716768^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^9277747372264086100.Either^9277747372264086100: Prelude.Types.Either Prelude.Types.Nat (DerivedGen.Z Prelude.Types.Nat)
+LOG deptycheck.derive.least-effort:7: DerivedGen.Z^4772972569107533783.Z^4772972569107533783[] Z^4772972569107533783^Con^0 - used final order: [#0]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] Either^13682636983817606971^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^9277747372264086100.Either^9277747372264086100[] Either^9277747372264086100^Con^0 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Either^9277747372264086100.Either^9277747372264086100[] Either^9277747372264086100^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] Z - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Types.Nat[] S - used final order: [#0]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^70731854558853028.Either^70731854558853028>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^70731854558853028.Either^70731854558853028"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Either^9277747372264086100.Either^9277747372264086100>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Either^9277747372264086100.Either^9277747372264086100"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.X>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Y^6741950274054397085.Y^6741950274054397085"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Z^15549736185298716768.Z^15549736185298716768>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Z^15549736185298716768.Z^15549736185298716768"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Types.Nat>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Types.Nat"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]"
+              [    var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>"
+                             [    var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^13682636983817606971.Either^13682636983817606971[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^13682636983817606971.Either^13682636983817606971^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^70731854558853028.Either^70731854558853028>[]"
+              [    var "<DerivedGen.Either^70731854558853028.Either^70731854558853028>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^70731854558853028.Either^70731854558853028"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^70731854558853028.Either^70731854558853028"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^0>>"
+                             [    var "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Z^4772972569107533783.mToP")
+                                          .$ (var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^1>>"
+                             [    var "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Z^15549736185298716768.mToP")
+                                          .$ (var "<DerivedGen.Z^15549736185298716768.Z^15549736185298716768>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^70731854558853028.Either^70731854558853028[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^70731854558853028.Either^70731854558853028^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Either^9277747372264086100.Either^9277747372264086100>[]"
+              [    var "<DerivedGen.Either^9277747372264086100.Either^9277747372264086100>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^9277747372264086100.Either^9277747372264086100"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Either^9277747372264086100.Either^9277747372264086100"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^0>>"
+                             [    var "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^0" .$ var "x")))
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^1>>"
+                             [    var "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (   var "fromString"
+                                      .$ primVal (Str "DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Z^4772972569107533783.mToP")
+                                          .$ (var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Either^9277747372264086100.Either^9277747372264086100[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Either^9277747372264086100.Either^9277747372264086100^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.X>[]"
+              [    var "<DerivedGen.X>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.MkX>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.X"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.MkX>>"
+                             [    var "<<DerivedGen.MkX>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.MkX (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Y^6741950274054397085.mToP")
+                                          .$ (var "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.MkX" .$ var "{arg:1}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.X[] (non-spending)"))
+                         .$ (var "<<DerivedGen.MkX>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]"
+              [    var "<DerivedGen.Y^6741950274054397085.Y^6741950274054397085>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Y^6741950274054397085.Y^6741950274054397085"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>"
+                             [    var "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^70731854558853028.mToP")
+                                          .$ (var "<DerivedGen.Either^70731854558853028.Either^70731854558853028>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0" .$ var "{arg:2}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Y^6741950274054397085.Y^6741950274054397085[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Y^6741950274054397085.Y^6741950274054397085^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Z^15549736185298716768.Z^15549736185298716768>[]"
+              [    var "<DerivedGen.Z^15549736185298716768.Z^15549736185298716768>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Z^15549736185298716768.Z^15549736185298716768^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Z^15549736185298716768.Z^15549736185298716768"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Z^15549736185298716768.Z^15549736185298716768^Con^0>>"
+                             [    var "<<DerivedGen.Z^15549736185298716768.Z^15549736185298716768^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^15549736185298716768.Z^15549736185298716768^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^9277747372264086100.mToP")
+                                          .$ (var "<DerivedGen.Either^9277747372264086100.Either^9277747372264086100>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Z^15549736185298716768.Z^15549736185298716768^Con^0" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^15549736185298716768.Z^15549736185298716768[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Z^15549736185298716768.Z^15549736185298716768^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]"
+              [    var "<DerivedGen.Z^4772972569107533783.Z^4772972569107533783>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>"
+                             [    var "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Either^13682636983817606971.mToP")
+                                          .$ (var "<DerivedGen.Either^13682636983817606971.Either^13682636983817606971>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:3}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0" .$ var "{arg:3}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Z^4772972569107533783.Z^4772972569107533783[] (non-spending)"))
+                         .$ (var "<<DerivedGen.Z^4772972569107533783.Z^4772972569107533783^Con^0>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Types.Nat>[]"
+              [    var "<Prelude.Types.Nat>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.Z>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Types.S>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "Prelude.Types.Nat"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.Z>>"
+                             [    var "<<Prelude.Types.Z>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.Z (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Types.Z")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Types.S>>"
+                             [    var "<<Prelude.Types.S>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Types.S (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Types.Nat>[]" .$ var "^cons_fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:4}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "Prelude.Types.S" .$ var "{arg:4}")))
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (dry fuel)"))
+                                    .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (var "fromString" .$ primVal (Str "Prelude.Types.Nat[] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (var "Builtin.MkPair" .$ var "Data.Nat1.one" .$ (var "<<Prelude.Types.Z>>" .$ var "^fuel_arg^"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (var "<<Prelude.Types.S>>" .$ var "^sub^fuel_arg^"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.X>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/run b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/06-4 ty deep hkd/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/07-0 list-lookup/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/DerivedGen.idr
new file mode 100644
index 000000000..9ba0c9359
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+%default total
+
+%language ElabReflection
+
+
+public export
+data Lookup : a -> List (a, b) -> Type where
+  Here : (y : b) -> Lookup x $ (x, y)::xys
+  There : Lookup z xys -> Lookup z $ (x, y)::xys
+
+data UseLookup : Type where
+  UL : Lookup True [(True, True, True, True)] -> UseLookup
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> Gen MaybeEmpty UseLookup
diff --git a/tests/derivation/least-effort/print/specialise/07-0 list-lookup/derive.ipkg b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/07-0 list-lookup/expected b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/expected
new file mode 100644
index 000000000..61e05e618
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/expected	
@@ -0,0 +1,364 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> Gen MaybeEmpty UseLookup
+LOG deptycheck.derive.least-effort:7: DerivedGen.UseLookup[] UL - used final order: [#0]
+LOG deptycheck.util.specialisation:10: DerivedGen.Lookup[0(b), 1(a), 2, 3] Declared specialised type DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048: DerivedGen.Lookup {b = Builtin.Pair Prelude.Basics.Bool (Builtin.Pair Prelude.Basics.Bool Prelude.Basics.Bool)} {a = Prelude.Basics.Bool} lam^0 lam^1
+LOG deptycheck.derive.least-effort:7: DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048[0(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0), 1(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1)] Lookup^7730538649293255048^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048[0(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0), 1(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1)] Lookup^7730538649293255048^Con^1 - used final order: [#4]
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048>[0, 1]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0") (var "Prelude.Basics.Bool")
+                           .-> MkArg
+                                 MW
+                                 ExplicitArg
+                                 (Just "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1")
+                                 (   var "Prelude.Basics.List"
+                                  .$ (   var "Builtin.Pair"
+                                      .$ var "Prelude.Basics.Bool"
+                                      .$ (   var "Builtin.Pair"
+                                          .$ var "Prelude.Basics.Bool"
+                                          .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))))
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048"
+                                   .$ var "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0"
+                                   .$ var "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.UseLookup>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.UseLookup"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048>[0, 1]"
+              [       var "<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048>[0, 1]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0>"
+                   .$ bindVar "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0") (var "Prelude.Basics.Bool")
+                                          .-> MkArg
+                                                MW
+                                                ExplicitArg
+                                                (Just "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1")
+                                                (   var "Prelude.Basics.List"
+                                                 .$ (   var "Builtin.Pair"
+                                                     .$ var "Prelude.Basics.Bool"
+                                                     .$ (   var "Builtin.Pair"
+                                                         .$ var "Prelude.Basics.Bool"
+                                                         .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))))
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048"
+                                                  .$ var "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0"
+                                                  .$ var "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0") (var "Prelude.Basics.Bool")
+                                          .-> MkArg
+                                                MW
+                                                ExplicitArg
+                                                (Just "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1")
+                                                (   var "Prelude.Basics.List"
+                                                 .$ (   var "Builtin.Pair"
+                                                     .$ var "Prelude.Basics.Bool"
+                                                     .$ (   var "Builtin.Pair"
+                                                         .$ var "Prelude.Basics.Bool"
+                                                         .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))))
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048"
+                                                  .$ var "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0"
+                                                  .$ var "fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                             [ withClause
+                                 { lhs =
+                                        var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                                     .$ bindVar "^cons_fuel^"
+                                     .$ bindVar "x"
+                                     .$ (   var "Prelude.Basics.(::)"
+                                         .! ( "a"
+                                            ,    var "Builtin.Pair"
+                                              .$ var "Prelude.Basics.Bool"
+                                              .$ (   var "Builtin.Pair"
+                                                  .$ var "Prelude.Basics.Bool"
+                                                  .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))
+                                            )
+                                         .$ (   var "Builtin.MkPair"
+                                             .! ("a", var "Prelude.Basics.Bool")
+                                             .! ( "b"
+                                                ,    var "Builtin.Pair"
+                                                  .$ var "Prelude.Basics.Bool"
+                                                  .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool")
+                                                )
+                                             .$ bindVar "to_be_deceqed^^x0"
+                                             .$ bindVar "y")
+                                         .$ bindVar "xys")
+                                 , rig = MW
+                                 , wval = var "Decidable.Equality.decEq" .$ var "to_be_deceqed^^x0" .$ var "x"
+                                 , prf = Nothing
+                                 , flags = []
+                                 , clauses =
+                                     [       var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                                          .$ bindVar "^cons_fuel^"
+                                          .$ bindVar "x"
+                                          .$ (   var "Prelude.Basics.(::)"
+                                              .! ( "a"
+                                                 ,    var "Builtin.Pair"
+                                                   .$ var "Prelude.Basics.Bool"
+                                                   .$ (   var "Builtin.Pair"
+                                                       .$ var "Prelude.Basics.Bool"
+                                                       .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))
+                                                 )
+                                              .$ (   var "Builtin.MkPair"
+                                                  .! ("a", var "Prelude.Basics.Bool")
+                                                  .! ( "b"
+                                                     ,    var "Builtin.Pair"
+                                                       .$ var "Prelude.Basics.Bool"
+                                                       .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool")
+                                                     )
+                                                  .$ bindVar "x"
+                                                  .$ bindVar "y")
+                                              .$ bindVar "xys")
+                                          .$ (var "Prelude.Yes" .$ var "Builtin.Refl")
+                                       .=    var "Test.DepTyCheck.Gen.label"
+                                          .$ (var "fromString" .$ primVal (Str "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0 (orders)"))
+                                          .$ (   var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0"
+                                                  .! ("x", var "x")
+                                                  .! ("xys", var "xys")
+                                                  .$ var "y"))
+                                     ,       var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                                          .$ bindVar "^cons_fuel^"
+                                          .$ bindVar "x"
+                                          .$ (   var "Prelude.Basics.(::)"
+                                              .! ( "a"
+                                                 ,    var "Builtin.Pair"
+                                                   .$ var "Prelude.Basics.Bool"
+                                                   .$ (   var "Builtin.Pair"
+                                                       .$ var "Prelude.Basics.Bool"
+                                                       .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))
+                                                 )
+                                              .$ (   var "Builtin.MkPair"
+                                                  .! ("a", var "Prelude.Basics.Bool")
+                                                  .! ( "b"
+                                                     ,    var "Builtin.Pair"
+                                                       .$ var "Prelude.Basics.Bool"
+                                                       .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool")
+                                                     )
+                                                  .$ bindVar "to_be_deceqed^^x0"
+                                                  .$ bindVar "y")
+                                              .$ bindVar "xys")
+                                          .$ (var "Prelude.No" .$ implicitTrue)
+                                       .= var "empty"
+                                     ]
+                                 }
+                             , var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1>>"
+                             [       var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ bindVar "z"
+                                  .$ (   var "Prelude.Basics.(::)"
+                                      .! ( "a"
+                                         ,    var "Builtin.Pair"
+                                           .$ var "Prelude.Basics.Bool"
+                                           .$ (   var "Builtin.Pair"
+                                               .$ var "Prelude.Basics.Bool"
+                                               .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))
+                                         )
+                                      .$ (   var "Builtin.MkPair"
+                                          .! ("a", var "Prelude.Basics.Bool")
+                                          .! ( "b"
+                                             ,    var "Builtin.Pair"
+                                               .$ var "Prelude.Basics.Bool"
+                                               .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool")
+                                             )
+                                          .$ bindVar "x"
+                                          .$ bindVar "y")
+                                      .$ bindVar "xys")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048>[0, 1]" .$ var "^cons_fuel^" .$ var "z" .$ var "xys")
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:1}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1"
+                                                  .! ("x", var "x")
+                                                  .! ("y", var "y")
+                                                  .! ("z", implicitTrue)
+                                                  .! ("xys", implicitTrue)
+                                                  .$ var "{arg:1}")))
+                             , var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048[0(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0), 1(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0>"
+                                        .$ var "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048[0(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0), 1(fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0>"
+                                                    .$ var "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^0>"
+                                                        .$ var "inter^<fv^Lookup^7730538649293255048.Lookup^7730538649293255048^lam^1>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.UseLookup>[]"
+              [    var "<DerivedGen.UseLookup>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.UL>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "DerivedGen.UseLookup"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.UL>>"
+                             [    var "<<DerivedGen.UL>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.UL (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Lookup^7730538649293255048.mToP")
+                                          .$ (   var "<DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048>[0, 1]"
+                                              .$ var "^outmost-fuel^"
+                                              .$ var "Prelude.Basics.True"
+                                              .$ (   var "Prelude.Basics.(::)"
+                                                  .! ( "a"
+                                                     ,    var "Builtin.Pair"
+                                                       .$ var "Prelude.Basics.Bool"
+                                                       .$ (   var "Builtin.Pair"
+                                                           .$ var "Prelude.Basics.Bool"
+                                                           .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))
+                                                     )
+                                                  .$ (   var "Builtin.MkPair"
+                                                      .! ("a", var "Prelude.Basics.Bool")
+                                                      .! ( "b"
+                                                         ,    var "Builtin.Pair"
+                                                           .$ var "Prelude.Basics.Bool"
+                                                           .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool")
+                                                         )
+                                                      .$ var "Prelude.Basics.True"
+                                                      .$ (   var "Builtin.MkPair"
+                                                          .! ("a", var "Prelude.Basics.Bool")
+                                                          .! ("b", var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool")
+                                                          .$ var "Prelude.Basics.True"
+                                                          .$ (   var "Builtin.MkPair"
+                                                              .! ("a", var "Prelude.Basics.Bool")
+                                                              .! ("b", var "Prelude.Basics.Bool")
+                                                              .$ var "Prelude.Basics.True"
+                                                              .$ var "Prelude.Basics.True")))
+                                                  .$ (   var "Prelude.Basics.Nil"
+                                                      .! ( "a"
+                                                         ,    var "Builtin.Pair"
+                                                           .$ var "Prelude.Basics.Bool"
+                                                           .$ (   var "Builtin.Pair"
+                                                               .$ var "Prelude.Basics.Bool"
+                                                               .$ (var "Builtin.Pair" .$ var "Prelude.Basics.Bool" .$ var "Prelude.Basics.Bool"))
+                                                         )))))
+                                      .$ (    MkArg MW ExplicitArg (Just "{arg:2}") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.UL" .$ var "{arg:2}")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.UseLookup[] (non-spending)"))
+                         .$ (var "<<DerivedGen.UL>>" .$ var "^fuel_arg^")
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.UseLookup>[]" .$ var "^outmost-fuel^"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/07-0 list-lookup/run b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-0 list-lookup/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/DerivedGen.idr b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/DerivedGen.idr
new file mode 100644
index 000000000..4b1ef30d7
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/DerivedGen.idr	
@@ -0,0 +1,33 @@
+module DerivedGen
+
+import Deriving.DepTyCheck.Gen
+
+import public Data.Fin
+import Data.Fuel
+import Data.String
+import Data.Vect
+import public Data.Vect.AtIndex
+
+import Decidable.Equality
+
+import Deriving.DepTyCheck.Gen
+
+%language ElabReflection
+
+%default total
+
+%language ElabReflection
+
+public export
+Regs : Nat -> Type
+Regs n = Vect n $ Maybe Bool
+
+public export
+RegIsType : Fin r -> Bool -> Regs r -> Type
+RegIsType fn t rs = AtIndex fn rs (Just t)
+
+public export
+data SimpleExpr : Regs r -> Bool -> Type where
+  Read    : (idx : Fin r) -> RegIsType idx t regs => SimpleExpr regs t
+
+%runElab deriveGenPrinter @{MainCoreDerivator @{LeastEffort}} $ Fuel -> (r : Nat) -> (t : Bool) -> Gen MaybeEmpty (a : Regs r ** SimpleExpr a t)
diff --git a/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/derive.ipkg b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/expected b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/expected
new file mode 100644
index 000000000..7f2a3901b
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/expected	
@@ -0,0 +1,674 @@
+1/1: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.derive.print:5: type: (arg : Fuel) -> (r : Nat) -> (t : Bool) -> Gen MaybeEmpty (a : Regs r ** SimpleExpr a t)
+LOG deptycheck.derive.least-effort:7: DerivedGen.SimpleExpr[0(r), 2] Read - used final order: [#4]
+LOG deptycheck.util.specialisation:10: Data.Vect.AtIndex.AtIndex[0(type), 1(n), 4(x)] Declared specialised type DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525: Data.Vect.AtIndex.AtIndex {type = Prelude.Types.Maybe Prelude.Basics.Bool} {n = lam^0} lam^1 lam^2 lam^3
+LOG deptycheck.derive.least-effort:7: DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525[0(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0), 3(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3)] AtIndex^2737362274073714525^Con^0 - used final order: [#2 (xs)]
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186: Data.Vect.Vect lam^0 (Prelude.Types.Maybe Prelude.Basics.Bool)
+LOG deptycheck.derive.least-effort:7: DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525[0(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0), 3(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3)] AtIndex^2737362274073714525^Con^1 - used final order: [#5 (later), #1 (y)]
+LOG deptycheck.util.specialisation:10: Prelude.Types.Maybe[0(ty)] Declared specialised type DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926: Prelude.Types.Maybe Prelude.Basics.Bool
+LOG deptycheck.derive.least-effort:7: DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926[] Maybe^2151327891283438926^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926[] Maybe^2151327891283438926^Con^1 - used final order: [#0 (x)]
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186[0(fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0)] Vect^15780912604163783186^Con^0 - used final order: []
+LOG deptycheck.derive.least-effort:7: DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186[0(fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0)] Vect^15780912604163783186^Con^1 - used final order: [#1 (x), #2 (xs)]
+LOG deptycheck.derive.least-effort:7: Prelude.Basics.Bool[] False - used final order: []
+LOG deptycheck.derive.least-effort:7: Prelude.Basics.Bool[] True - used final order: []
+    MkArg MW ExplicitArg (Just "^outmost-fuel^") (var "Data.Fuel.Fuel")
+.=> MkArg MW ExplicitArg (Just "outer^<r>") implicitTrue
+.=> MkArg MW ExplicitArg (Just "outer^<t>") implicitTrue
+.=> local
+      { decls =
+          [ IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525>[0, 3]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0") (var "Prelude.Types.Nat")
+                           .-> MkArg
+                                 MW
+                                 ExplicitArg
+                                 (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3")
+                                 (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ (var "Data.Fin.Fin" .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0")
+                                   .$ (    MkArg
+                                             MW
+                                             ExplicitArg
+                                             (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^1")
+                                             (var "Data.Fin.Fin" .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0")
+                                       .=>    var "Builtin.DPair.DPair"
+                                           .$ (   var "Data.Vect.Vect"
+                                               .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                               .$ (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool"))
+                                           .$ (    MkArg
+                                                     MW
+                                                     ExplicitArg
+                                                     (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^2")
+                                                     (   var "Data.Vect.Vect"
+                                                      .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                      .$ (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool"))
+                                               .=>    var "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525"
+                                                   .! ( "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                      , var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                      )
+                                                   .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^1"
+                                                   .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^2"
+                                                   .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3")))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186>[0]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0") (var "Prelude.Types.Nat")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186"
+                                   .$ var "fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0")
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.SimpleExpr>[0, 2]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> MkArg MW ExplicitArg (Just "r") (var "Prelude.Types.Nat")
+                           .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Basics.Bool")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ (   var "Builtin.DPair.DPair"
+                                   .$ (var "DerivedGen.Regs" .$ var "r")
+                                   .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "DerivedGen.Regs" .$ var "r")
+                                       .=> var "DerivedGen.SimpleExpr" .! ("r", var "r") .$ var "{arg:2}" .$ var "{arg:1}"))
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .->    var "Test.DepTyCheck.Gen.Gen"
+                               .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                               .$ var "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926"
+                       }
+                 })
+          , IClaim
+              (MkIClaimData
+                 { rig = MW
+                 , vis = Export
+                 , opts = []
+                 , type =
+                     mkTy
+                       { name = "<Prelude.Basics.Bool>[]"
+                       , type =
+                               MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                           .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Basics.Bool"
+                       }
+                 })
+          , IDef
+              emptyFC
+              "<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525>[0, 3]"
+              [       var "<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525>[0, 3]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0>"
+                   .$ bindVar "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg
+                                                MW
+                                                ExplicitArg
+                                                (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3")
+                                                (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ (var "Data.Fin.Fin" .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0")
+                                                  .$ (    MkArg
+                                                            MW
+                                                            ExplicitArg
+                                                            (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^1")
+                                                            (var "Data.Fin.Fin" .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0")
+                                                      .=>    var "Builtin.DPair.DPair"
+                                                          .$ (   var "Data.Vect.Vect"
+                                                              .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                              .$ (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool"))
+                                                          .$ (    MkArg
+                                                                    MW
+                                                                    ExplicitArg
+                                                                    (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^2")
+                                                                    (   var "Data.Vect.Vect"
+                                                                     .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                                     .$ (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool"))
+                                                              .=>    var "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525"
+                                                                  .! ( "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                                     , var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                                     )
+                                                                  .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^1"
+                                                                  .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^2"
+                                                                  .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3")))
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0") (var "Prelude.Types.Nat")
+                                          .-> MkArg
+                                                MW
+                                                ExplicitArg
+                                                (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3")
+                                                (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ (var "Data.Fin.Fin" .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0")
+                                                  .$ (    MkArg
+                                                            MW
+                                                            ExplicitArg
+                                                            (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^1")
+                                                            (var "Data.Fin.Fin" .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0")
+                                                      .=>    var "Builtin.DPair.DPair"
+                                                          .$ (   var "Data.Vect.Vect"
+                                                              .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                              .$ (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool"))
+                                                          .$ (    MkArg
+                                                                    MW
+                                                                    ExplicitArg
+                                                                    (Just "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^2")
+                                                                    (   var "Data.Vect.Vect"
+                                                                     .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                                     .$ (var "Prelude.Types.Maybe" .$ var "Prelude.Basics.Bool"))
+                                                              .=>    var "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525"
+                                                                  .! ( "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                                     , var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0"
+                                                                     )
+                                                                  .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^1"
+                                                                  .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^2"
+                                                                  .$ var "fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3")))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0>>"
+                             [       var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "{len:1}")
+                                  .$ bindVar "x"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Vect^15780912604163783186.mToP")
+                                          .$ (var "<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186>[0]" .$ var "^outmost-fuel^" .$ var "{len:1}"))
+                                      .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (   var "Builtin.DPair.MkDPair"
+                                                  .$ implicitTrue
+                                                  .$ (   var "Builtin.DPair.MkDPair"
+                                                      .$ implicitTrue
+                                                      .$ (   var "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0"
+                                                          .! ("{len:1}", implicitTrue)
+                                                          .! ("x", var "x")
+                                                          .! ("xs", var "xs"))))))
+                             ,    var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue
+                               .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1>>"
+                             [       var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "{n:1}")
+                                  .$ bindVar "x"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525>[0, 3]" .$ var "^cons_fuel^" .$ var "{n:1}" .$ var "x")
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [    var "Builtin.DPair.MkDPair" .$ bindVar "rest" .$ (var "Builtin.DPair.MkDPair" .$ bindVar "xs" .$ bindVar "later")
+                                                      .=    var ">>="
+                                                         .$ (   var "map"
+                                                             .$ (var "cast" .@ var "DerivedGen.Maybe^2151327891283438926.mToP")
+                                                             .$ (var "<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926>[]" .$ var "^outmost-fuel^"))
+                                                         .$ (    MkArg MW ExplicitArg (Just "y") implicitFalse
+                                                             .=>    var "Prelude.pure"
+                                                                 .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                                 .$ (   var "Builtin.DPair.MkDPair"
+                                                                     .$ implicitTrue
+                                                                     .$ (   var "Builtin.DPair.MkDPair"
+                                                                         .$ implicitTrue
+                                                                         .$ (   var "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1"
+                                                                             .! ("{n:1}", implicitTrue)
+                                                                             .! ("y", var "y")
+                                                                             .! ("x", implicitTrue)
+                                                                             .! ("xs", implicitTrue)
+                                                                             .! ("rest", implicitTrue)
+                                                                             .$ var "later"))))
+                                                    ]
+                                                }))
+                             ,    var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1>>" .$ implicitTrue .$ implicitTrue .$ implicitTrue
+                               .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525[0(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0), 3(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0>"
+                                        .$ var "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525[0(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0), 3(fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0>"
+                                                    .$ var "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^0>"
+                                                        .$ var "inter^<fv^AtIndex^2737362274073714525.AtIndex^2737362274073714525^lam^3>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186>[0]"
+              [       var "<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186>[0]"
+                   .$ bindVar "^fuel_arg^"
+                   .$ bindVar "inter^<fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186"
+                                                  .$ var "fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0")
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0") (var "Prelude.Types.Nat")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186"
+                                                  .$ var "fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0")
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0>>"
+                             [    var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0>>" .$ bindVar "^cons_fuel^" .$ var "Prelude.Types.Z"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0")
+                             , var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1>>"
+                             [       var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1>>"
+                                  .$ bindVar "^cons_fuel^"
+                                  .$ (var "Prelude.Types.S" .$ bindVar "len")
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "map"
+                                          .$ (var "cast" .@ var "DerivedGen.Maybe^2151327891283438926.mToP")
+                                          .$ (var "<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926>[]" .$ var "^outmost-fuel^"))
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var ">>="
+                                              .$ (var "<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186>[0]" .$ var "^cons_fuel^" .$ var "len")
+                                              .$ (    MkArg MW ExplicitArg (Just "xs") implicitFalse
+                                                  .=>    var "Prelude.pure"
+                                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                      .$ (   var "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1"
+                                                          .! ("len", implicitTrue)
+                                                          .$ var "x"
+                                                          .$ var "xs"))))
+                             , var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1>>" .$ implicitTrue .$ implicitTrue .= var "empty"
+                             ]
+                         ]
+                     , scope =
+                         iCase
+                           { sc = var "^fuel_arg^"
+                           , ty = var "Data.Fuel.Fuel"
+                           , clauses =
+                               [    var "Data.Fuel.Dry"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186[0(fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0)] (dry fuel)"))
+                                    .$ (   var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0>>"
+                                        .$ var "^fuel_arg^"
+                                        .$ var "inter^<fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0>")
+                               ,    var "Data.Fuel.More" .$ bindVar "^sub^fuel_arg^"
+                                 .=    var "Test.DepTyCheck.Gen.label"
+                                    .$ (   var "fromString"
+                                        .$ primVal
+                                             (Str
+                                                "DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186[0(fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0)] (non-dry fuel)"))
+                                    .$ (   var "Test.DepTyCheck.Gen.frequency"
+                                        .$ (   var "::"
+                                            .$ (   var "Builtin.MkPair"
+                                                .$ var "Data.Nat1.one"
+                                                .$ (   var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^0>>"
+                                                    .$ var "^fuel_arg^"
+                                                    .$ var "inter^<fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0>"))
+                                            .$ (   var "::"
+                                                .$ (   var "Builtin.MkPair"
+                                                    .$ (var "Deriving.DepTyCheck.Gen.ConsRecs.leftDepth" .$ var "^sub^fuel_arg^")
+                                                    .$ (   var "<<DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186^Con^1>>"
+                                                        .$ var "^sub^fuel_arg^"
+                                                        .$ var "inter^<fv^Vect^15780912604163783186.Vect^15780912604163783186^lam^0>"))
+                                                .$ var "Nil")))
+                               ]
+                           }
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.SimpleExpr>[0, 2]"
+              [    var "<DerivedGen.SimpleExpr>[0, 2]" .$ bindVar "^fuel_arg^" .$ bindVar "inter^<r>" .$ bindVar "inter^<{arg:1}>"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Read>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> MkArg MW ExplicitArg (Just "r") (var "Prelude.Types.Nat")
+                                          .-> MkArg MW ExplicitArg (Just "{arg:1}") (var "Prelude.Basics.Bool")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ (   var "Builtin.DPair.DPair"
+                                                  .$ (var "DerivedGen.Regs" .$ var "r")
+                                                  .$ (    MkArg MW ExplicitArg (Just "{arg:2}") (var "DerivedGen.Regs" .$ var "r")
+                                                      .=> var "DerivedGen.SimpleExpr" .! ("r", var "r") .$ var "{arg:2}" .$ var "{arg:1}"))
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Read>>"
+                             [    var "<<DerivedGen.Read>>" .$ bindVar "^cons_fuel^" .$ bindVar "r" .$ bindVar "t"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Read (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (   var "the"
+                                          .$ (   var "Gen"
+                                              .$ var "MaybeEmpty"
+                                              .$ (   var "DPair"
+                                                  .$ implicitFalse
+                                                  .$ (    MkArg MW ExplicitArg Nothing implicitFalse
+                                                      .=> var "DPair" .$ implicitFalse .$ (MkArg MW ExplicitArg Nothing implicitFalse .=> implicitFalse))))
+                                          .$ (   var "map"
+                                              .$ (    MkArg MW ExplicitArg (Just "invv") implicitFalse
+                                                  .=> iCase
+                                                        { sc = var "invv"
+                                                        , ty = implicitFalse
+                                                        , clauses =
+                                                            [    var "MkDPair" .$ bindVar "dph^1" .$ (var "MkDPair" .$ bindVar "dph^0" .$ bindVar "inv")
+                                                              .=    var "MkDPair"
+                                                                 .$ var "dph^1"
+                                                                 .$ (   var "MkDPair"
+                                                                     .$ var "dph^0"
+                                                                     .$ (var "cast" .@ var "DerivedGen.AtIndex^2737362274073714525.mToP" .$ var "inv"))
+                                                            ]
+                                                        })
+                                              .$ (   var "<DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525>[0, 3]"
+                                                  .$ var "^outmost-fuel^"
+                                                  .$ var "r"
+                                                  .$ (var "Prelude.Types.Just" .! ("ty", var "Prelude.Basics.Bool") .$ var "t"))))
+                                      .$ (    MkArg MW ExplicitArg (Just "{lamc:1}") implicitFalse
+                                          .=> iCase
+                                                { sc = var "{lamc:1}"
+                                                , ty = implicitFalse
+                                                , clauses =
+                                                    [       var "Builtin.DPair.MkDPair"
+                                                         .$ bindVar "idx"
+                                                         .$ (var "Builtin.DPair.MkDPair" .$ bindVar "regs" .$ bindVar "{conArg:1}")
+                                                      .=    var "Prelude.pure"
+                                                         .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                                         .$ (   var "Builtin.DPair.MkDPair"
+                                                             .$ implicitTrue
+                                                             .$ (   var "DerivedGen.Read"
+                                                                 .! ("r", implicitTrue)
+                                                                 .! ("regs", implicitTrue)
+                                                                 .! ("t", implicitTrue)
+                                                                 .$ implicitTrue
+                                                                 .@ var "{conArg:1}"))
+                                                    ]
+                                                }))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.SimpleExpr[0(r), 2] (non-spending)"))
+                         .$ (var "<<DerivedGen.Read>>" .$ var "^fuel_arg^" .$ var "inter^<r>" .$ var "inter^<{arg:1}>")
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926>[]"
+              [    var "<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^0>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^1>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .->    var "Test.DepTyCheck.Gen.Gen"
+                                              .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty"
+                                              .$ var "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^0>>"
+                             [    var "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^0>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^0 (orders)"))
+                                  .$ (   var "Prelude.pure"
+                                      .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                      .$ var "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^0")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^1>>"
+                             [    var "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^1>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^1 (orders)"))
+                                  .$ (   var ">>="
+                                      .$ (var "<Prelude.Basics.Bool>[]" .$ var "^outmost-fuel^")
+                                      .$ (    MkArg MW ExplicitArg (Just "x") implicitFalse
+                                          .=>    var "Prelude.pure"
+                                              .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue)
+                                              .$ (var "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^1" .$ var "x")))
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^0>>" .$ var "^fuel_arg^")
+                                 .$ (   var "::"
+                                     .$ (var "<<DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926^Con^1>>" .$ var "^fuel_arg^")
+                                     .$ var "Nil")))
+                     }
+              ]
+          , IDef
+              emptyFC
+              "<Prelude.Basics.Bool>[]"
+              [    var "<Prelude.Basics.Bool>[]" .$ bindVar "^fuel_arg^"
+                .= local
+                     { decls =
+                         [ IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Basics.False>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Basics.Bool"
+                                      }
+                                })
+                         , IClaim
+                             (MkIClaimData
+                                { rig = MW
+                                , vis = Export
+                                , opts = []
+                                , type =
+                                    mkTy
+                                      { name = "<<Prelude.Basics.True>>"
+                                      , type =
+                                              MkArg MW ExplicitArg Nothing (var "Data.Fuel.Fuel")
+                                          .-> var "Test.DepTyCheck.Gen.Gen" .$ var "Test.DepTyCheck.Gen.Emptiness.MaybeEmpty" .$ var "Prelude.Basics.Bool"
+                                      }
+                                })
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Basics.False>>"
+                             [    var "<<Prelude.Basics.False>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Basics.False (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Basics.False")
+                             ]
+                         , IDef
+                             emptyFC
+                             "<<Prelude.Basics.True>>"
+                             [    var "<<Prelude.Basics.True>>" .$ bindVar "^cons_fuel^"
+                               .=    var "Test.DepTyCheck.Gen.label"
+                                  .$ (var "fromString" .$ primVal (Str "Prelude.Basics.True (orders)"))
+                                  .$ (var "Prelude.pure" .! ("f", var "Test.DepTyCheck.Gen.Gen" .$ implicitTrue) .$ var "Prelude.Basics.True")
+                             ]
+                         ]
+                     , scope =
+                            var "Test.DepTyCheck.Gen.label"
+                         .$ (var "fromString" .$ primVal (Str "Prelude.Basics.Bool[] (non-spending)"))
+                         .$ (   var "Test.DepTyCheck.Gen.oneOf"
+                             .! ("em", var "MaybeEmpty")
+                             .$ (   var "::"
+                                 .$ (var "<<Prelude.Basics.False>>" .$ var "^fuel_arg^")
+                                 .$ (var "::" .$ (var "<<Prelude.Basics.True>>" .$ var "^fuel_arg^") .$ var "Nil")))
+                     }
+              ]
+          ]
+      , scope = var "<DerivedGen.SimpleExpr>[0, 2]" .$ var "^outmost-fuel^" .$ var "outer^<r>" .$ var "outer^<t>"
+      }
+
diff --git a/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/run b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/07-1 vect-indexed-multargspec/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/print/specialise/_common b/tests/derivation/least-effort/print/specialise/_common
new file mode 120000
index 000000000..3342f309f
--- /dev/null
+++ b/tests/derivation/least-effort/print/specialise/_common
@@ -0,0 +1 @@
+../../../_common
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/gadt/015 mem/DerivedGen.idr b/tests/derivation/least-effort/run/gadt/015 mem/DerivedGen.idr
index 58c39b479..44da011fd 100644
--- a/tests/derivation/least-effort/run/gadt/015 mem/DerivedGen.idr	
+++ b/tests/derivation/least-effort/run/gadt/015 mem/DerivedGen.idr	
@@ -49,6 +49,7 @@ Show (AtIndex idx ty mut) where
   show _ = "indeed"
 
 %hide Prelude.Basics.(:<)
+%hide Data.SnocVect.(:<)
 
 main : IO ()
 main = runGs
diff --git a/tests/derivation/least-effort/run/specialise/00-1 simple/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-1 simple/DerivedGen.idr
new file mode 100644
index 000000000..b3738c072
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-1 simple/DerivedGen.idr	
@@ -0,0 +1,16 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data X = MkX (List Nat)
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/00-1 simple/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-1 simple/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-1 simple/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-1 simple/derive.ipkg b/tests/derivation/least-effort/run/specialise/00-1 simple/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-1 simple/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-1 simple/expected b/tests/derivation/least-effort/run/specialise/00-1 simple/expected
new file mode 100644
index 000000000..6beee5ec3
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-1 simple/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX [16, 4, 17, 10, 8, 17, 12, 11, 10, 4]
+-----
+MkX [14, 4, 14, 7, 1, 6, 0, 15, 17, 17, 20, 14, 20, 5, 19, 12, 9, 14, 16]
+-----
+MkX [16, 8, 0, 2, 2, 6, 12, 17, 19, 7, 3, 16, 6, 12, 15, 1]
+-----
+MkX [5, 0, 17, 15]
+-----
+MkX [6]
+-----
+MkX [19, 1, 20, 1, 18, 14, 3]
+-----
+MkX [2, 13, 15, 20, 3, 1, 13, 8, 4]
+-----
+MkX [7, 3, 6, 5, 16, 2, 4, 2, 5]
+-----
+MkX [4, 10, 1, 10, 11, 13, 19, 15]
+-----
+MkX [12, 8, 17, 1, 13, 8, 6, 20, 13, 2, 17, 13, 6, 19]
diff --git a/tests/derivation/least-effort/run/specialise/00-1 simple/run b/tests/derivation/least-effort/run/specialise/00-1 simple/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-1 simple/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-2 simple/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-2 simple/DerivedGen.idr
new file mode 100644
index 000000000..eff62e143
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-2 simple/DerivedGen.idr	
@@ -0,0 +1,16 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data X = MkX (List String)
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G $ \fl => checkedGen fl @{const $ elements ["a", "b", "c", "cc"]} ]
diff --git a/tests/derivation/least-effort/run/specialise/00-2 simple/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-2 simple/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-2 simple/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-2 simple/derive.ipkg b/tests/derivation/least-effort/run/specialise/00-2 simple/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-2 simple/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-2 simple/expected b/tests/derivation/least-effort/run/specialise/00-2 simple/expected
new file mode 100644
index 000000000..eaf84492b
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-2 simple/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^8984676908526435328.List^8984676908526435328: Prelude.Basics.List String
+Generated values:
+-----
+-----
+MkX ["a", "a", "b", "cc", "b", "c", "cc", "c", "b", "b"]
+-----
+MkX ["a", "b", "a", "b", "cc", "b", "cc", "b", "cc", "cc", "c", "b", "a", "cc", "c", "c", "a", "c", "a", "a"]
+-----
+MkX ["a", "c", "b", "a", "b", "cc", "a", "b", "cc", "a", "cc", "a", "cc", "b", "cc", "b", "a", "c", "b", "b"]
+-----
+MkX ["c", "cc", "b", "cc"]
+-----
+MkX ["a", "b", "c", "b", "b", "a"]
+-----
+MkX ["cc", "a", "c", "b", "a", "c", "c", "c", "a"]
+-----
+MkX ["cc", "cc", "cc", "a", "a", "cc", "cc", "cc", "a", "b", "cc", "b", "b", "b", "a", "b"]
+-----
+MkX ["cc", "cc", "b", "c", "c", "b", "a", "b", "c", "a", "b", "b"]
+-----
+MkX ["a", "b"]
+-----
+MkX ["c", "a", "cc", "b", "b"]
diff --git a/tests/derivation/least-effort/run/specialise/00-2 simple/run b/tests/derivation/least-effort/run/specialise/00-2 simple/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-2 simple/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/DerivedGen.idr
new file mode 100644
index 000000000..c251bf3d9
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/DerivedGen.idr	
@@ -0,0 +1,16 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data X = MkX (List Nat) (List Nat)
+
+Show X where
+  showPrec d $ MkX xs ys = showCon d "MkX" $ showArg xs ++ showArg ys
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/derive.ipkg b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/expected b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/expected
new file mode 100644
index 000000000..aabbe0423
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX [16, 4, 17, 10, 8, 17, 12, 11, 10, 4] [14, 4, 14, 7, 1, 6, 0, 15, 17, 17, 20, 14, 20, 5, 19, 12, 9, 14, 16]
+-----
+MkX [16, 8, 0, 2, 2, 6, 12, 17, 19, 7, 3, 16, 6, 12, 15, 1] [5, 0, 17, 15]
+-----
+MkX [6] [19, 1, 20, 1, 18, 14, 3]
+-----
+MkX [2, 13, 15, 20, 3, 1, 13, 8, 4] [7, 3, 6, 5, 16, 2, 4, 2, 5]
+-----
+MkX [4, 10, 1, 10, 11, 13, 19, 15] [12, 8, 17, 1, 13, 8, 6, 20, 13, 2, 17, 13, 6, 19]
+-----
+MkX [19, 12, 8, 20, 12, 19, 17, 1, 11, 20, 14, 0, 0, 2, 16] [18, 12, 3, 4, 15, 12]
+-----
+MkX [17, 7, 15, 4, 6, 4, 15, 14, 10, 10, 0, 4, 17, 16, 1, 6, 0, 0, 13] [4, 13, 6, 8, 7]
+-----
+MkX [17, 13, 8, 10, 5, 8, 1] [13, 3, 14, 12, 16, 5, 17, 14, 0, 5, 7, 19, 16]
+-----
+MkX [6, 5, 6, 20, 3, 1, 1, 10, 11, 1, 0, 14, 2, 6, 15, 18] [1, 13, 15, 9, 9, 19, 17, 3, 17, 1, 12, 7, 14, 17, 14]
+-----
+MkX [10, 12, 13, 15, 6, 18, 4, 17, 4, 14, 8, 15, 13, 0, 16, 15, 13, 18] [13, 4, 15, 3]
diff --git a/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/run b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-3 two-same shallow/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-4 two-same deep/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/DerivedGen.idr
new file mode 100644
index 000000000..9e3266e3d
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/DerivedGen.idr	
@@ -0,0 +1,21 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data Y = MkY (List Nat)
+
+data X = MkX (List Nat) Y
+
+Show Y where
+  showPrec d $ MkY xs = showCon d "MkY" $ showArg xs
+
+Show X where
+  showPrec d $ MkX xs y = showCon d "MkX" $ showArg xs ++ showArg y
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/00-4 two-same deep/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-4 two-same deep/derive.ipkg b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-4 two-same deep/expected b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/expected
new file mode 100644
index 000000000..a03a8cd38
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX [16, 4, 17, 10, 8, 17, 12, 11, 10, 4] (MkY [14, 4, 14, 7, 1, 6, 0, 15, 17, 17, 20, 14, 20, 5, 19, 12, 9, 14, 16])
+-----
+MkX [16, 8, 0, 2, 2, 6, 12, 17, 19, 7, 3, 16, 6, 12, 15, 1] (MkY [5, 0, 17, 15])
+-----
+MkX [6] (MkY [19, 1, 20, 1, 18, 14, 3])
+-----
+MkX [2, 13, 15, 20, 3, 1, 13, 8, 4] (MkY [7, 3, 6, 5, 16, 2, 4, 2, 5])
+-----
+MkX [4, 10, 1, 10, 11, 13, 19, 15] (MkY [12, 8, 17, 1, 13, 8, 6, 20, 13, 2, 17, 13, 6, 19])
+-----
+MkX [19, 12, 8, 20, 12, 19, 17, 1, 11, 20, 14, 0, 0, 2, 16] (MkY [18, 12, 3, 4, 15, 12])
+-----
+MkX [17, 7, 15, 4, 6, 4, 15, 14, 10, 10, 0, 4, 17, 16, 1, 6, 0, 0, 13] (MkY [4, 13, 6, 8, 7])
+-----
+MkX [17, 13, 8, 10, 5, 8, 1] (MkY [13, 3, 14, 12, 16, 5, 17, 14, 0, 5, 7, 19, 16])
+-----
+MkX [6, 5, 6, 20, 3, 1, 1, 10, 11, 1, 0, 14, 2, 6, 15, 18] (MkY [1, 13, 15, 9, 9, 19, 17, 3, 17, 1, 12, 7, 14, 17, 14])
+-----
+MkX [10, 12, 13, 15, 6, 18, 4, 17, 4, 14, 8, 15, 13, 0, 16, 15, 13, 18] (MkY [13, 4, 15, 3])
diff --git a/tests/derivation/least-effort/run/specialise/00-4 two-same deep/run b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-4 two-same deep/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-5 two-similar/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-5 two-similar/DerivedGen.idr
new file mode 100644
index 000000000..615167537
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-5 two-similar/DerivedGen.idr	
@@ -0,0 +1,16 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data X = MkX (List String) (List Nat)
+
+Show X where
+  showPrec d $ MkX xs ys = showCon d "MkX" $ showArg xs ++ showArg ys
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G $ \fl => checkedGen fl @{const $ elements ["a", "b", "c", "cc"]} ]
diff --git a/tests/derivation/least-effort/run/specialise/00-5 two-similar/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/00-5 two-similar/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-5 two-similar/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-5 two-similar/derive.ipkg b/tests/derivation/least-effort/run/specialise/00-5 two-similar/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-5 two-similar/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/00-5 two-similar/expected b/tests/derivation/least-effort/run/specialise/00-5 two-similar/expected
new file mode 100644
index 000000000..727de6bfa
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-5 two-similar/expected	
@@ -0,0 +1,26 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^8984676908526435328.List^8984676908526435328: Prelude.Basics.List String
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX ["a", "a", "b", "cc", "b", "c", "cc", "c", "b", "b"] [4, 17, 10, 8, 17, 12, 11, 10, 4]
+-----
+MkX ["cc", "cc", "cc", "a", "a", "cc", "cc", "cc", "a", "b", "cc", "b", "b", "b", "a", "b"] [14, 7, 1, 6, 0, 15, 17, 17, 13, 17, 19, 12]
+-----
+MkX ["a", "c", "c", "a", "c", "cc", "c", "c", "b", "b", "c", "c", "cc", "a", "b", "b", "c", "b"] [3, 10, 14, 16, 16, 11, 1, 2, 2, 6, 12, 17, 20, 7, 3, 15, 6, 12, 15]
+-----
+MkX ["a", "b", "c", "a", "a", "c", "a", "b", "a", "a", "a", "b", "c", "a", "c", "c", "b"] [15, 0, 6]
+-----
+MkX ["c", "b", "a", "c", "b", "b", "a", "a", "c", "a", "a", "a", "a", "cc", "cc", "c", "b", "cc", "cc"] [6, 18, 12, 3]
+-----
+MkX ["b", "b"] [13, 16, 20, 3, 0, 13, 8, 4]
+-----
+MkX ["a", "b", "c", "b"] [3, 6, 5, 16, 2, 4, 2, 5, 10, 10, 1, 10, 8, 13, 19, 15]
+-----
+MkX ["c", "a", "cc", "a", "cc", "c", "a", "a", "cc", "c", "cc", "cc", "c", "b", "b", "cc"] [17, 1, 13, 8, 6, 20, 13, 2, 17, 13, 6, 19, 19, 13, 8]
+-----
+MkX ["c", "cc", "c", "b", "c", "c", "a", "b", "c", "cc", "c", "cc", "c", "a", "b", "cc", "a", "a"] [8, 19, 17, 0, 11, 20, 14, 1, 0, 2, 18]
+-----
+MkX ["c", "b", "cc", "a", "cc", "c", "c", "cc", "cc", "c", "cc"] [12, 3, 4, 15, 5]
diff --git a/tests/derivation/least-effort/run/specialise/00-5 two-similar/run b/tests/derivation/least-effort/run/specialise/00-5 two-similar/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/00-5 two-similar/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/DerivedGen.idr
new file mode 100644
index 000000000..52c627a94
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n String -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => (n : _) -> Gen MaybeEmpty $ X n
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen @{smallStrs} fl 0
+  , G $ \fl => checkedGen @{smallStrs} fl 1
+  , G $ \fl => checkedGen @{smallStrs} fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/derive.ipkg b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/expected b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/expected
new file mode 100644
index 000000000..4ded567ff
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^120651999565177027.Vect^120651999565177027: Data.Vect.Vect lam^0 String
+Generated values:
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+MkX [""]
+-----
+MkX ["a"]
+-----
+MkX [""]
+-----
+MkX [""]
+-----
+MkX ["bc"]
+-----
+MkX ["a"]
+-----
+MkX [""]
+-----
+MkX ["a"]
+-----
+MkX ["bc"]
+-----
+MkX ["a"]
+-----
+-----
+MkX ["a", "a", "a"]
+-----
+MkX ["", "bc", "a"]
+-----
+MkX ["", "", "a"]
+-----
+MkX ["bc", "", ""]
+-----
+MkX ["a", "a", "bc"]
+-----
+MkX ["a", "a", "bc"]
+-----
+MkX ["bc", "bc", "bc"]
+-----
+MkX ["", "bc", "bc"]
+-----
+MkX ["", "bc", ""]
+-----
+MkX ["a", "", "a"]
diff --git a/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/run b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-1 non-ty imm givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/DerivedGen.idr
new file mode 100644
index 000000000..2631401c7
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n String -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty (n ** X n)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G $ \fl => checkedGen fl @{smallStrs} ]
diff --git a/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/expected b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/expected
new file mode 100644
index 000000000..b88cb9db5
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^120651999565177027.Vect^120651999565177027: Data.Vect.Vect lam^0 String
+Generated values:
+-----
+-----
+(16 ** MkX ["a", "a", "a", "bc", "", "a", "a", "bc", "a", "bc", "", "", "a", "a", "", ""])
+-----
+(12 ** MkX ["a", "a", "", "bc", "a", "", "bc", "", "", "a", "bc", "bc"])
+-----
+(0 ** MkX [])
+-----
+(17 ** MkX ["a", "a", "a", "", "", "bc", "a", "a", "bc", "", "bc", "", "a", "a", "a", "bc", "a"])
+-----
+(8 ** MkX ["a", "bc", "bc", "a", "bc", "", "", "bc"])
+-----
+(8 ** MkX ["", "bc", "", "bc", "a", "", "bc", ""])
+-----
+(10 ** MkX ["", "bc", "", "a", "bc", "", "a", "", "a", ""])
+-----
+(5 ** MkX ["", "bc", "a", "a", "a"])
+-----
+(4 ** MkX ["a", "", "bc", "bc"])
+-----
+(7 ** MkX ["a", "a", "", "a", "", "", ""])
diff --git a/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/run b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-2 non-ty imm gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/DerivedGen.idr
new file mode 100644
index 000000000..ef613c59f
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/DerivedGen.idr	
@@ -0,0 +1,17 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X = MkX (Vect n String)
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G $ \fl => checkedGen fl @{smallStrs} ]
diff --git a/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/derive.ipkg b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/expected b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/expected
new file mode 100644
index 000000000..f5d628864
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^120651999565177027.Vect^120651999565177027: Data.Vect.Vect lam^0 String
+Generated values:
+-----
+-----
+MkX ["a", "a", "a", "bc", "", "a", "a", "bc", "a", "bc", "", "", "a", "a", "", ""]
+-----
+MkX ["a", "a", "", "bc", "a", "", "bc", "", "", "a", "bc", "bc"]
+-----
+MkX []
+-----
+MkX ["a", "a", "a", "", "", "bc", "a", "a", "bc", "", "bc", "", "a", "a", "a", "bc", "a"]
+-----
+MkX ["a", "bc", "bc", "a", "bc", "", "", "bc"]
+-----
+MkX ["", "bc", "", "bc", "a", "", "bc", ""]
+-----
+MkX ["", "bc", "", "a", "bc", "", "a", "", "a", ""]
+-----
+MkX ["", "bc", "a", "a", "a"]
+-----
+MkX ["a", "", "bc", "bc"]
+-----
+MkX ["a", "a", "", "a", "", "", ""]
diff --git a/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/run b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/01-3 non-ty imm exist/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/DerivedGen.idr
new file mode 100644
index 000000000..49b3f73f5
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/DerivedGen.idr	
@@ -0,0 +1,16 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data X = MkX (List $ Fin n)
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/derive.ipkg b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/expected b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/expected
new file mode 100644
index 000000000..de95d61ac
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+Generated values:
+-----
+-----
+MkX [4, 14, 7, 9, 15, 1, 5, 7, 12]
+-----
+MkX [5, 10, 10, 3, 1, 6, 6, 3, 0, 2, 7, 1, 9, 6, 10, 6]
+-----
+MkX [11, 15, 15, 14, 1, 16, 12, 2, 8, 13, 14, 12, 12, 4, 1, 1, 2, 9, 15, 16]
+-----
+MkX [16, 2, 11, 6, 12, 15, 1]
+-----
+MkX [0, 2, 0, 4, 4, 1, 4, 3, 1, 0, 3]
+-----
+MkX []
+-----
+MkX [1, 18, 1, 18, 12, 3]
+-----
+MkX [0, 2, 2, 2, 0, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX []
diff --git a/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/run b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-0 non-ty deep exist/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/DerivedGen.idr
new file mode 100644
index 000000000..d19384dee
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Fin
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : List (Fin n) -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty (n ** X n)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/expected b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/expected
new file mode 100644
index 000000000..ae6a8c506
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+Generated values:
+-----
+-----
+(16 ** MkX [4, 14, 7, 9, 15, 1, 5, 7, 12])
+-----
+(11 ** MkX [5, 10, 10, 3, 1, 6, 6, 3, 0, 2, 7, 1, 9, 6, 10, 6])
+-----
+(17 ** MkX [11, 15, 15, 14, 1, 16, 12, 2, 8, 13, 14, 12, 12, 4, 1, 1, 2, 9, 15, 16])
+-----
+(19 ** MkX [16, 2, 11, 6, 12, 15, 1])
+-----
+(5 ** MkX [0, 2, 0, 4, 4, 1, 4, 3, 1, 0, 3])
+-----
+(0 ** MkX [])
+-----
+(19 ** MkX [1, 18, 1, 18, 12, 3])
+-----
+(3 ** MkX [0, 2, 2, 2, 0, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 0])
+-----
+(1 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(5 ** MkX [])
diff --git a/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/run b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-1 non-ty deep gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/DerivedGen.idr
new file mode 100644
index 000000000..684da47af
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Fin
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : List (Fin n) -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (n : _) -> Gen MaybeEmpty $ X n
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0
+  , G $ \fl => checkedGen fl 1
+  , G $ \fl => checkedGen fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/derive.ipkg b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/expected b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/expected
new file mode 100644
index 000000000..7faae5372
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+Generated values:
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0]
+-----
+MkX [0, 0, 0, 0, 0]
+-----
+-----
+MkX [0, 0, 2, 0, 2, 2, 0, 2, 0, 2, 1, 2, 2, 1, 2, 2, 0, 2]
+-----
+MkX [0, 2, 2, 1, 2, 2, 1, 2, 2, 0, 2, 0, 0, 2, 0, 2, 2, 2]
+-----
+MkX []
+-----
+MkX [1, 2, 2, 2]
+-----
+MkX [2, 0, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2, 0, 2, 0, 2, 1, 1, 2, 2]
+-----
+MkX [2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0]
+-----
+MkX [2, 2, 2, 2, 1, 2, 2, 1, 2, 1, 2, 2, 2, 1, 0, 2, 1, 1, 1]
+-----
+MkX [2, 2, 2, 2, 0, 0, 2, 1, 2, 2, 2, 2, 2, 1]
+-----
+MkX [0, 2, 1, 2, 2, 2, 2, 0, 2, 0, 1, 2, 2, 2]
+-----
+MkX [2, 2, 2, 1, 2, 2, 0, 1, 2, 2, 1, 2, 0, 0, 2, 0, 2]
diff --git a/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/run b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-2 non-ty deep givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-3 two-similar/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-3 two-similar/DerivedGen.idr
new file mode 100644
index 000000000..81f0281fa
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-3 two-similar/DerivedGen.idr	
@@ -0,0 +1,16 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data X = MkX (List String) (List $ Fin n)
+
+Show X where
+  showPrec d $ MkX xs ys = showCon d "MkX" $ showArg xs ++ showArg ys
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G $ \fl => checkedGen @{smallStrs} fl ]
diff --git a/tests/derivation/least-effort/run/specialise/02-3 two-similar/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/02-3 two-similar/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-3 two-similar/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-3 two-similar/derive.ipkg b/tests/derivation/least-effort/run/specialise/02-3 two-similar/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-3 two-similar/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/02-3 two-similar/expected b/tests/derivation/least-effort/run/specialise/02-3 two-similar/expected
new file mode 100644
index 000000000..e30868e61
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-3 two-similar/expected	
@@ -0,0 +1,26 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^8984676908526435328.List^8984676908526435328: Prelude.Basics.List String
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type DerivedGen.List^12757670414100080037.List^12757670414100080037: Prelude.Basics.List (Data.Fin.Fin lam^0)
+Generated values:
+-----
+-----
+MkX ["", "", "a", "", "bc", "", "a", "a", "", "", "a"] [8, 10, 15, 5, 4, 11]
+-----
+MkX ["", "bc", "bc", "bc", "", "bc", "bc", "bc", ""] [6, 12, 4, 5, 5, 9, 0, 14, 2, 14, 1, 13, 10, 13, 14, 14, 1]
+-----
+MkX [] [12, 9, 13, 15, 15, 11, 1, 2, 2, 9, 11, 17, 17, 16, 4, 15, 5, 11, 14]
+-----
+MkX ["", "a", "bc", "", "", "bc", "", "a", "", "", "", "a", "bc", "", "bc", "bc", "a"] [0, 6]
+-----
+MkX ["bc", "a", "", "bc", "a", "a", "", "", "bc", "", "", "", "", "bc", "bc", "bc", "a", "bc", "a", "bc"] [5, 5, 5, 2, 4, 4, 3, 0]
+-----
+MkX ["a", ""] [0, 2, 2, 2, 0, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 0]
+-----
+MkX ["", "bc", "", "bc", "a", "", "a", "a", "", "", "", "", "a", "a"] []
+-----
+MkX ["a", "bc", "a"] [1, 1, 3, 0, 3, 0, 3, 3, 1, 0, 3]
+-----
+MkX ["", "a"] [4, 3, 0]
+-----
+MkX ["a", "", "a", "", "a", "", ""] [9, 10, 5, 10, 10, 7]
diff --git a/tests/derivation/least-effort/run/specialise/02-3 two-similar/run b/tests/derivation/least-effort/run/specialise/02-3 two-similar/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/02-3 two-similar/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/DerivedGen.idr
new file mode 100644
index 000000000..782f15edb
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/DerivedGen.idr	
@@ -0,0 +1,17 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X = MkX (Vect n $ Fin n)
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/derive.ipkg b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/expected b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/expected
new file mode 100644
index 000000000..5cd1d4ac3
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX [6, 6, 5, 13, 7, 14, 6, 10, 0, 12, 7, 6, 14, 3, 11, 14]
+-----
+MkX [9, 8, 9, 9, 8, 8, 8, 9, 0, 9]
+-----
+MkX [16, 13, 7, 16, 3, 8, 19, 18, 13, 7, 3, 3, 1, 9, 17, 17, 15, 11, 3, 15]
+-----
+MkX [0, 1]
+-----
+MkX [2, 0, 2]
+-----
+MkX [9, 9, 6, 8, 0, 4, 0, 3, 1, 6]
+-----
+MkX [1, 1]
+-----
+MkX [6, 8, 3, 3, 7, 13, 7, 8, 13, 13, 3, 0, 4, 1]
+-----
+MkX [0, 0, 1, 2, 0]
+-----
+MkX [2, 4, 0, 5, 0, 4]
diff --git a/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/run b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-0 non-ty imm-deep-same exist/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/DerivedGen.idr
new file mode 100644
index 000000000..ee7dec47d
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin n) -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty (n ** X n)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/expected b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/expected
new file mode 100644
index 000000000..2f5f4faf0
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+(16 ** MkX [6, 6, 5, 13, 7, 14, 6, 10, 0, 12, 7, 6, 14, 3, 11, 14])
+-----
+(10 ** MkX [9, 8, 9, 9, 8, 8, 8, 9, 0, 9])
+-----
+(20 ** MkX [16, 13, 7, 16, 3, 8, 19, 18, 13, 7, 3, 3, 1, 9, 17, 17, 15, 11, 3, 15])
+-----
+(2 ** MkX [0, 1])
+-----
+(3 ** MkX [2, 0, 2])
+-----
+(10 ** MkX [9, 9, 6, 8, 0, 4, 0, 3, 1, 6])
+-----
+(2 ** MkX [1, 1])
+-----
+(14 ** MkX [6, 8, 3, 3, 7, 13, 7, 8, 13, 13, 3, 0, 4, 1])
+-----
+(5 ** MkX [0, 0, 1, 2, 0])
+-----
+(6 ** MkX [2, 4, 0, 5, 0, 4])
diff --git a/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/run b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-1 non-ty imm-deep-same gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/DerivedGen.idr
new file mode 100644
index 000000000..9a9f83fe2
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin n) -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (n : _) -> Gen MaybeEmpty $ X n
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0
+  , G $ \fl => checkedGen fl 1
+  , G $ \fl => checkedGen fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/derive.ipkg b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/expected b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/expected
new file mode 100644
index 000000000..593d4d098
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+-----
+MkX [2, 0, 2]
+-----
+MkX [2, 1, 0]
+-----
+MkX [2, 1, 2]
+-----
+MkX [2, 2, 2]
+-----
+MkX [1, 2, 1]
+-----
+MkX [2, 2, 2]
+-----
+MkX [2, 2, 2]
+-----
+MkX [0, 2, 1]
+-----
+MkX [2, 0, 2]
+-----
+MkX [2, 2, 2]
diff --git a/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/run b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/03-2 non-ty imm-deep-same givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/DerivedGen.idr
new file mode 100644
index 000000000..a62adafaa
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/DerivedGen.idr	
@@ -0,0 +1,17 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X = MkX (Vect n $ Fin m)
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/expected b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/expected
new file mode 100644
index 000000000..df25aa7ad
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX [3, 11, 8, 15]
+-----
+MkX [6, 10, 0, 13, 7]
+-----
+MkX [6, 5, 12, 2]
+-----
+MkX [3, 3, 0, 3, 3, 3, 3, 3, 0, 1]
+-----
+MkX [5, 4, 6, 6, 7, 6, 1, 0, 5, 7, 7, 7, 7, 6, 7, 4, 7]
+-----
+MkX [4, 1, 4, 2, 0, 6, 2, 4, 6, 6, 6, 4, 6, 3]
+-----
+MkX [0, 9, 6, 5, 3, 3, 7, 9, 9, 8, 9, 9]
+-----
+MkX [0, 11, 11, 6, 10, 0, 6, 0, 5, 3, 11, 6, 6, 5, 2, 5, 0, 2]
+-----
+MkX [3, 18, 5, 18, 13, 3, 0, 4, 6]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
diff --git a/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/run b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-0 non-ty imm-deep-diff exist-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/DerivedGen.idr
new file mode 100644
index 000000000..3cf94ab15
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X m
+
+Show (X m) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (m : _) -> Gen MaybeEmpty $ X m
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0
+  , G $ \fl => checkedGen fl 1
+  , G $ \fl => checkedGen fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/expected b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/expected
new file mode 100644
index 000000000..bb47f5b28
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0]
+-----
+MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+-----
+-----
+MkX [1, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 0, 2, 1]
+-----
+MkX [2, 2, 0, 1, 2]
+-----
+MkX [2, 2, 2, 2, 2, 0, 0, 2, 2]
+-----
+MkX [2, 0, 2, 2, 0, 2]
+-----
+MkX [1, 2, 0]
+-----
+MkX [2, 2, 2, 2, 2, 1, 0, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2]
+-----
+MkX [2, 0]
+-----
+MkX [1, 2, 2, 2, 2, 1, 2, 0, 1, 1, 2, 2, 2, 2, 2]
+-----
+MkX [2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, 1]
+-----
+MkX [1, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 0, 0, 0, 0, 1, 1]
diff --git a/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/run b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-1 non-ty imm-deep-diff exist-givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/DerivedGen.idr
new file mode 100644
index 000000000..933c98627
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (n : _) -> Gen MaybeEmpty $ X n
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0
+  , G $ \fl => checkedGen fl 1
+  , G $ \fl => checkedGen fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/expected b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/expected
new file mode 100644
index 000000000..994625a20
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+MkX [1]
+-----
+MkX [8]
+-----
+MkX [2]
+-----
+MkX [3]
+-----
+MkX [3]
+-----
+MkX [6]
+-----
+MkX [2]
+-----
+MkX [13]
+-----
+MkX [4]
+-----
+MkX [0]
+-----
+-----
+MkX [8, 15, 1]
+-----
+MkX [4, 2, 9]
+-----
+MkX [0, 2, 3]
+-----
+MkX [10, 0, 2]
+-----
+MkX [6, 3, 7]
+-----
+MkX [1, 1, 3]
+-----
+MkX [13, 1, 14]
+-----
+MkX [11, 12, 11]
+-----
+MkX [4, 8, 8]
+-----
+MkX [9, 1, 9]
diff --git a/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/run b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-2 non-ty imm-deep-diff exist-givn/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/DerivedGen.idr
new file mode 100644
index 000000000..4dc3ba664
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X m
+
+Show (X m) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty (m ** X m)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/expected b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/expected
new file mode 100644
index 000000000..af6ffcb99
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+(16 ** MkX [3, 11, 8, 15])
+-----
+(17 ** MkX [6, 10, 0, 13, 7])
+-----
+(15 ** MkX [6, 5, 12, 2])
+-----
+(4 ** MkX [3, 3, 0, 3, 3, 3, 3, 3, 0, 1])
+-----
+(8 ** MkX [5, 4, 6, 6, 7, 6, 1, 0, 5, 7, 7, 7, 7, 6, 7, 4, 7])
+-----
+(7 ** MkX [4, 1, 4, 2, 0, 6, 2, 4, 6, 6, 6, 4, 6, 3])
+-----
+(10 ** MkX [0, 9, 6, 5, 3, 3, 7, 9, 9, 8, 9, 9])
+-----
+(12 ** MkX [0, 11, 11, 6, 10, 0, 6, 0, 5, 3, 11, 6, 6, 5, 2, 5, 0, 2])
+-----
+(19 ** MkX [3, 18, 5, 18, 13, 3, 0, 4, 6])
+-----
+(1 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
diff --git a/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/run b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-3 non-ty imm-deep-diff exist-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/DerivedGen.idr
new file mode 100644
index 000000000..3e5c39e4b
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Type where
+  MkX : Vect n (Fin m) -> X n
+
+Show (X n) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty (n ** X n)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/expected b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/expected
new file mode 100644
index 000000000..7d4350a1d
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+(4 ** MkX [3, 11, 8, 15])
+-----
+(5 ** MkX [6, 10, 0, 13, 7])
+-----
+(4 ** MkX [6, 5, 12, 2])
+-----
+(10 ** MkX [3, 3, 0, 3, 3, 3, 3, 3, 0, 1])
+-----
+(17 ** MkX [5, 4, 6, 6, 7, 6, 1, 0, 5, 7, 7, 7, 7, 6, 7, 4, 7])
+-----
+(14 ** MkX [4, 1, 4, 2, 0, 6, 2, 4, 6, 6, 6, 4, 6, 3])
+-----
+(12 ** MkX [0, 9, 6, 5, 3, 3, 7, 9, 9, 8, 9, 9])
+-----
+(18 ** MkX [0, 11, 11, 6, 10, 0, 6, 0, 5, 3, 11, 6, 6, 5, 2, 5, 0, 2])
+-----
+(9 ** MkX [3, 18, 5, 18, 13, 3, 0, 4, 6])
+-----
+(13 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
diff --git a/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/run b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-4 non-ty imm-deep-diff exist-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/DerivedGen.idr
new file mode 100644
index 000000000..942158aaa
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+Show (X n m) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty (n ** m ** X n m)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/expected b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/expected
new file mode 100644
index 000000000..be59fcd1e
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+(4 ** (16 ** MkX [3, 11, 8, 15]))
+-----
+(5 ** (17 ** MkX [6, 10, 0, 13, 7]))
+-----
+(4 ** (15 ** MkX [6, 5, 12, 2]))
+-----
+(10 ** (4 ** MkX [3, 3, 0, 3, 3, 3, 3, 3, 0, 1]))
+-----
+(17 ** (8 ** MkX [5, 4, 6, 6, 7, 6, 1, 0, 5, 7, 7, 7, 7, 6, 7, 4, 7]))
+-----
+(14 ** (7 ** MkX [4, 1, 4, 2, 0, 6, 2, 4, 6, 6, 6, 4, 6, 3]))
+-----
+(12 ** (10 ** MkX [0, 9, 6, 5, 3, 3, 7, 9, 9, 8, 9, 9]))
+-----
+(18 ** (12 ** MkX [0, 11, 11, 6, 10, 0, 6, 0, 5, 3, 11, 6, 6, 5, 2, 5, 0, 2]))
+-----
+(9 ** (19 ** MkX [3, 18, 5, 18, 13, 3, 0, 4, 6]))
+-----
+(13 ** (1 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
diff --git a/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/run b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-5 non-ty imm-deep-diff gend-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/DerivedGen.idr
new file mode 100644
index 000000000..4ee821e55
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/DerivedGen.idr	
@@ -0,0 +1,26 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+Show (X n m) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (n, m : _) -> Gen MaybeEmpty $ X n m
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0 0
+  , G $ \fl => checkedGen fl 0 3
+  , G $ \fl => checkedGen fl 1 0
+  , G $ \fl => checkedGen fl 1 1
+  , G $ \fl => checkedGen fl 1 3
+  , G $ \fl => checkedGen fl 3 1
+  , G $ \fl => checkedGen fl 3 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/expected b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/expected
new file mode 100644
index 000000000..cdd411198
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/expected	
@@ -0,0 +1,131 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+MkX []
+-----
+-----
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+MkX [0]
+-----
+-----
+MkX [1]
+-----
+MkX [2]
+-----
+MkX [2]
+-----
+MkX [2]
+-----
+MkX [0]
+-----
+MkX [2]
+-----
+MkX [2]
+-----
+MkX [1]
+-----
+MkX [2]
+-----
+MkX [2]
+-----
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+MkX [0, 0, 0]
+-----
+-----
+MkX [2, 0, 2]
+-----
+MkX [2, 1, 0]
+-----
+MkX [2, 1, 2]
+-----
+MkX [2, 2, 2]
+-----
+MkX [1, 2, 1]
+-----
+MkX [2, 2, 2]
+-----
+MkX [2, 2, 2]
+-----
+MkX [0, 2, 1]
+-----
+MkX [2, 0, 2]
+-----
+MkX [2, 2, 2]
diff --git a/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/run b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-6 non-ty imm-deep-diff givn-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/DerivedGen.idr
new file mode 100644
index 000000000..b60b928a8
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+Show (X n m) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (n : _) -> Gen MaybeEmpty (m ** X n m)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0
+  , G $ \fl => checkedGen fl 1
+  , G $ \fl => checkedGen fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/expected b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/expected
new file mode 100644
index 000000000..49ad508b2
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+(16 ** MkX [])
+-----
+(4 ** MkX [])
+-----
+(17 ** MkX [])
+-----
+(10 ** MkX [])
+-----
+(8 ** MkX [])
+-----
+(17 ** MkX [])
+-----
+(12 ** MkX [])
+-----
+(12 ** MkX [])
+-----
+(10 ** MkX [])
+-----
+(4 ** MkX [])
+-----
+-----
+(16 ** MkX [1])
+-----
+(17 ** MkX [8])
+-----
+(10 ** MkX [2])
+-----
+(17 ** MkX [3])
+-----
+(4 ** MkX [3])
+-----
+(7 ** MkX [6])
+-----
+(8 ** MkX [2])
+-----
+(18 ** MkX [13])
+-----
+(7 ** MkX [4])
+-----
+(10 ** MkX [0])
+-----
+-----
+(16 ** MkX [8, 15, 1])
+-----
+(10 ** MkX [4, 2, 9])
+-----
+(4 ** MkX [0, 2, 3])
+-----
+(11 ** MkX [10, 0, 2])
+-----
+(10 ** MkX [6, 3, 7])
+-----
+(4 ** MkX [1, 1, 3])
+-----
+(15 ** MkX [13, 1, 14])
+-----
+(13 ** MkX [11, 12, 11])
+-----
+(9 ** MkX [4, 8, 8])
+-----
+(10 ** MkX [9, 1, 9])
diff --git a/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/run b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-7 non-ty imm-deep-diff givn-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/DerivedGen.idr
new file mode 100644
index 000000000..b9ca75356
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/DerivedGen.idr	
@@ -0,0 +1,22 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Nat -> Nat -> Type where
+  MkX : Vect n (Fin m) -> X n m
+
+Show (X n m) where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (m : _) -> Gen MaybeEmpty (n ** X n m)
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs
+  [ G $ \fl => checkedGen fl 0
+  , G $ \fl => checkedGen fl 1
+  , G $ \fl => checkedGen fl 3
+  ]
diff --git a/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/derive.ipkg b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/expected b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/expected
new file mode 100644
index 000000000..5360cfd7d
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/expected	
@@ -0,0 +1,67 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+(0 ** MkX [])
+-----
+-----
+(16 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(17 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(17 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(12 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(8 ** MkX [0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(16 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+(5 ** MkX [0, 0, 0, 0, 0])
+-----
+(4 ** MkX [0, 0, 0, 0])
+-----
+(6 ** MkX [0, 0, 0, 0, 0, 0])
+-----
+(15 ** MkX [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+-----
+-----
+(16 ** MkX [1, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 0, 2, 1])
+-----
+(5 ** MkX [2, 2, 0, 1, 2])
+-----
+(9 ** MkX [2, 2, 2, 2, 2, 0, 0, 2, 2])
+-----
+(6 ** MkX [2, 0, 2, 2, 0, 2])
+-----
+(3 ** MkX [1, 2, 0])
+-----
+(18 ** MkX [2, 2, 2, 2, 2, 1, 0, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2])
+-----
+(2 ** MkX [2, 0])
+-----
+(15 ** MkX [1, 2, 2, 2, 2, 1, 2, 0, 1, 1, 2, 2, 2, 2, 2])
+-----
+(13 ** MkX [2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, 1])
+-----
+(18 ** MkX [1, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 0, 0, 0, 0, 1, 1])
diff --git a/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/run b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/04-8 non-ty imm-deep-diff givn-gend/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/DerivedGen.idr
new file mode 100644
index 000000000..9c8324851
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/DerivedGen.idr	
@@ -0,0 +1,18 @@
+module DerivedGen
+
+import Data.Vect
+import RunDerivedGen
+
+%default total
+
+data X : Type where
+  MkX : Vect n (Fin n) -> Either (n `LT` m) (m `LT` n) => X
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/derive.ipkg b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/expected b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/expected
new file mode 100644
index 000000000..4d7106cf1
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/expected	
@@ -0,0 +1,26 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^6814960928365568963.Either^6814960928365568963: Prelude.Types.Either (Data.Nat.LTE lam^0 lam^1) (Data.Nat.LTE lam^2 lam^3)
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^1863907217212445550.Vect^1863907217212445550: Data.Vect.Vect lam^0 (Data.Fin.Fin lam^1)
+Generated values:
+-----
+-----
+MkX [6, 6, 5, 13, 7, 14, 6, 10, 0, 12, 7, 6, 14, 3, 11, 7]
+-----
+MkX [8, 9, 8, 9, 9, 8, 8, 8, 9, 2]
+-----
+MkX [3, 10, 7, 11, 11, 11, 7, 11, 1, 11, 5, 11]
+-----
+MkX [1, 2, 1]
+-----
+MkX [16, 2, 15, 3, 0, 6, 1, 14, 12, 6, 0, 7, 2, 1, 16, 15, 3]
+-----
+MkX [0, 4, 0, 0, 1, 3]
+-----
+MkX [2, 1, 2]
+-----
+MkX [2, 0, 0, 3, 1, 4, 0, 7, 1]
+-----
+MkX [1, 0]
+-----
+MkX [10, 10, 10, 4, 5, 9, 2, 2, 10, 0, 5]
diff --git a/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/run b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/05-0 non-ty complex exist-both/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-0 ty shallow/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/DerivedGen.idr
new file mode 100644
index 000000000..1bf026caa
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/DerivedGen.idr	
@@ -0,0 +1,23 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data Y : Type -> Type where
+  MkY : Either Nat a -> Y a
+
+data X : Type where
+  MkX : Either Nat (Y Nat) -> X
+
+Show a => Show (Y a) where
+  showPrec d $ MkY e = showCon d "MkY" $ showArg e
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/06-0 ty shallow/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-0 ty shallow/derive.ipkg b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-0 ty shallow/expected b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/expected
new file mode 100644
index 000000000..78b18e824
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/expected	
@@ -0,0 +1,27 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^4289176107705670177.Either^4289176107705670177: Prelude.Types.Either Prelude.Types.Nat (DerivedGen.Y Prelude.Types.Nat)
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0] Declared specialised type DerivedGen.Y^11712255676025100806.Y^11712255676025100806: DerivedGen.Y Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX (Right (MkY (Left 16)))
+-----
+MkX (Left 4)
+-----
+MkX (Left 17)
+-----
+MkX (Left 10)
+-----
+MkX (Left 8)
+-----
+MkX (Right (MkY (Right 17)))
+-----
+MkX (Right (MkY (Left 11)))
+-----
+MkX (Right (MkY (Left 11)))
+-----
+MkX (Left 10)
+-----
+MkX (Left 4)
diff --git a/tests/derivation/least-effort/run/specialise/06-0 ty shallow/run b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-0 ty shallow/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-1 ty deeper/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/DerivedGen.idr
new file mode 100644
index 000000000..511995433
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/DerivedGen.idr	
@@ -0,0 +1,23 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data Y : Type -> Type where
+  MkY : Either Nat a -> Y a
+
+data X : Type where
+  MkX : Either Nat (Y $ Either (Fin 5) String) -> X
+
+Show a => Show (Y a) where
+  showPrec d $ MkY e = showCon d "MkY" $ showArg e
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> (Fuel -> Gen MaybeEmpty String) => Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G $ \fl => checkedGen @{smallStrs} fl ]
diff --git a/tests/derivation/least-effort/run/specialise/06-1 ty deeper/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-1 ty deeper/derive.ipkg b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-1 ty deeper/expected b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/expected
new file mode 100644
index 000000000..489311cc3
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/expected	
@@ -0,0 +1,28 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^17089122808763292221.Either^17089122808763292221: Prelude.Types.Either Prelude.Types.Nat (DerivedGen.Y (Prelude.Types.Either (Data.Fin.Fin lam^0) String))
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0] Declared specialised type DerivedGen.Y^7167106520753982886.Y^7167106520753982886: DerivedGen.Y (Prelude.Types.Either (Data.Fin.Fin lam^0) String)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^5595291053177582713.Either^5595291053177582713: Prelude.Types.Either Prelude.Types.Nat (Prelude.Types.Either (Data.Fin.Fin lam^0) String)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13748098436294604892.Either^13748098436294604892: Prelude.Types.Either (Data.Fin.Fin lam^0) String
+Generated values:
+-----
+-----
+MkX (Right (MkY (Left 16)))
+-----
+MkX (Left 4)
+-----
+MkX (Left 17)
+-----
+MkX (Left 10)
+-----
+MkX (Left 8)
+-----
+MkX (Right (MkY (Right (Right "a"))))
+-----
+MkX (Right (MkY (Left 17)))
+-----
+MkX (Right (MkY (Left 11)))
+-----
+MkX (Right (MkY (Left 11)))
+-----
+MkX (Left 10)
diff --git a/tests/derivation/least-effort/run/specialise/06-1 ty deeper/run b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-1 ty deeper/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-2 ty deep/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-2 ty deep/DerivedGen.idr
new file mode 100644
index 000000000..18e238caf
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-2 ty deep/DerivedGen.idr	
@@ -0,0 +1,29 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data Z : Type -> Type where
+  MkZ : Either Nat a -> Z a
+
+data Y : Type -> Type where
+  MkY : Either (Z a) a -> Y a
+
+data X : Type where
+  MkX : Y Nat -> X
+
+Show a => Show (Z a) where
+  showPrec d $ MkZ e = showCon d "MkZ" $ showArg e
+
+Show a => Show (Y a) where
+  showPrec d $ MkY e = showCon d "MkY" $ showArg e
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/06-2 ty deep/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-2 ty deep/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-2 ty deep/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-2 ty deep/derive.ipkg b/tests/derivation/least-effort/run/specialise/06-2 ty deep/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-2 ty deep/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-2 ty deep/expected b/tests/derivation/least-effort/run/specialise/06-2 ty deep/expected
new file mode 100644
index 000000000..8184164fd
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-2 ty deep/expected	
@@ -0,0 +1,28 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0] Declared specialised type DerivedGen.Y^11712255676025100806.Y^11712255676025100806: DerivedGen.Y Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^8529713418737914198.Either^8529713418737914198: Prelude.Types.Either (DerivedGen.Z Prelude.Types.Nat) Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^4772972569107533783.Z^4772972569107533783: DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX (MkY (Right 16))
+-----
+MkX (MkY (Left (MkZ (Left 3))))
+-----
+MkX (MkY (Left (MkZ (Left 17))))
+-----
+MkX (MkY (Left (MkZ (Right 10))))
+-----
+MkX (MkY (Left (MkZ (Left 8))))
+-----
+MkX (MkY (Right 17))
+-----
+MkX (MkY (Right 12))
+-----
+MkX (MkY (Right 12))
+-----
+MkX (MkY (Left (MkZ (Right 7))))
+-----
+MkX (MkY (Left (MkZ (Right 3))))
diff --git a/tests/derivation/least-effort/run/specialise/06-2 ty deep/run b/tests/derivation/least-effort/run/specialise/06-2 ty deep/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-2 ty deep/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/DerivedGen.idr
new file mode 100644
index 000000000..143d65a1d
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/DerivedGen.idr	
@@ -0,0 +1,29 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data Z : Type -> Type where
+  MkZ : Either Nat a -> Z a
+
+data Y : (Type -> Type) -> Type -> Type where
+  MkY : Either (f a) a -> Y f a
+
+data X : Type where
+  MkX : Y Z Nat -> X
+
+Show a => Show (Z a) where
+  showPrec d $ MkZ e = showCon d "MkZ" $ showArg e
+
+Show (f a) => Show a => Show (Y f a) where
+  showPrec d $ MkY e = showCon d "MkY" $ showArg e
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/derive.ipkg b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/expected b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/expected
new file mode 100644
index 000000000..b9823f974
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/expected	
@@ -0,0 +1,28 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0, 1] Declared specialised type DerivedGen.Y^6741950274054397085.Y^6741950274054397085: DerivedGen.Y DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^8529713418737914198.Either^8529713418737914198: Prelude.Types.Either (DerivedGen.Z Prelude.Types.Nat) Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^4772972569107533783.Z^4772972569107533783: DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX (MkY (Right 16))
+-----
+MkX (MkY (Left (MkZ (Left 3))))
+-----
+MkX (MkY (Left (MkZ (Left 17))))
+-----
+MkX (MkY (Left (MkZ (Right 10))))
+-----
+MkX (MkY (Left (MkZ (Left 8))))
+-----
+MkX (MkY (Right 17))
+-----
+MkX (MkY (Right 12))
+-----
+MkX (MkY (Right 12))
+-----
+MkX (MkY (Left (MkZ (Right 7))))
+-----
+MkX (MkY (Left (MkZ (Right 3))))
diff --git a/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/run b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-3 ty deep hkd/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/DerivedGen.idr
new file mode 100644
index 000000000..49a06b209
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/DerivedGen.idr	
@@ -0,0 +1,29 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+data Z : Type -> Type where
+  MkZ : Either Nat a -> Z a
+
+data Y : (Type -> Type) -> Type -> Type where
+  MkY : Either (f a) (f $ f a) -> Y f a
+
+data X : Type where
+  MkX : Y Z Nat -> X
+
+Show a => Show (Z a) where
+  showPrec d $ MkZ e = showCon d "MkZ" $ showArg e
+
+Show (f a) => Show (f $ f a) => Show (Y f a) where
+  showPrec d $ MkY e = showCon d "MkY" $ showArg e
+
+Show X where
+  showPrec d $ MkX xs = showCon d "MkX" $ showArg xs
+
+checkedGen : Fuel -> Gen MaybeEmpty X
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/derive.ipkg b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/expected b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/expected
new file mode 100644
index 000000000..8784cc719
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/expected	
@@ -0,0 +1,30 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: DerivedGen.Y[0, 1] Declared specialised type DerivedGen.Y^6741950274054397085.Y^6741950274054397085: DerivedGen.Y DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^70731854558853028.Either^70731854558853028: Prelude.Types.Either (DerivedGen.Z Prelude.Types.Nat) (DerivedGen.Z (DerivedGen.Z Prelude.Types.Nat))
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^4772972569107533783.Z^4772972569107533783: DerivedGen.Z Prelude.Types.Nat
+LOG deptycheck.util.specialisation:10: DerivedGen.Z[0] Declared specialised type DerivedGen.Z^15549736185298716768.Z^15549736185298716768: DerivedGen.Z (DerivedGen.Z Prelude.Types.Nat)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^9277747372264086100.Either^9277747372264086100: Prelude.Types.Either Prelude.Types.Nat (DerivedGen.Z Prelude.Types.Nat)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Either[0(a), 1(b)] Declared specialised type DerivedGen.Either^13682636983817606971.Either^13682636983817606971: Prelude.Types.Either Prelude.Types.Nat Prelude.Types.Nat
+Generated values:
+-----
+-----
+MkX (MkY (Right (MkZ (Left 16))))
+-----
+MkX (MkY (Left (MkZ (Left 3))))
+-----
+MkX (MkY (Left (MkZ (Left 17))))
+-----
+MkX (MkY (Left (MkZ (Right 10))))
+-----
+MkX (MkY (Left (MkZ (Left 8))))
+-----
+MkX (MkY (Right (MkZ (Right (MkZ (Right 17))))))
+-----
+MkX (MkY (Right (MkZ (Left 11))))
+-----
+MkX (MkY (Right (MkZ (Left 11))))
+-----
+MkX (MkY (Left (MkZ (Right 7))))
+-----
+MkX (MkY (Left (MkZ (Right 3))))
diff --git a/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/run b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/06-4 ty deep hkd/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/07-0 list-lookup/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/DerivedGen.idr
new file mode 100644
index 000000000..b3f9de613
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/DerivedGen.idr	
@@ -0,0 +1,27 @@
+module DerivedGen
+
+import RunDerivedGen
+
+%default total
+
+
+public export
+data Lookup : a -> List (a, b) -> Type where
+  Here : (y : b) -> Lookup x $ (x, y)::xys
+  There : Lookup z xys -> Lookup z $ (x, y)::xys
+
+data UseLookup : Type where
+  UL : Lookup True [(True, True, True, True)] -> UseLookup
+
+Show a => Show b => Show (Lookup {a=a} {b=b} x xs) where
+  showPrec d $ Here y = showCon d "Here" $ showArg y
+  showPrec d $ There y = showCon d "There" $ showArg y
+
+Show UseLookup where
+  showPrec d $ UL y = showCon d "UL" $ showArg y
+
+checkedGen : Fuel -> Gen MaybeEmpty UseLookup
+checkedGen = deriveGen @{MainCoreDerivator @{LeastEffort}}
+
+main : IO Unit
+main = runGs [ G checkedGen ]
diff --git a/tests/derivation/least-effort/run/specialise/07-0 list-lookup/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/07-0 list-lookup/derive.ipkg b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/07-0 list-lookup/expected b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/expected
new file mode 100644
index 000000000..ed9687930
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/expected	
@@ -0,0 +1,25 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: DerivedGen.Lookup[0(b), 1(a), 2, 3] Declared specialised type DerivedGen.Lookup^7730538649293255048.Lookup^7730538649293255048: DerivedGen.Lookup {b = Builtin.Pair Prelude.Basics.Bool (Builtin.Pair Prelude.Basics.Bool Prelude.Basics.Bool)} {a = Prelude.Basics.Bool} lam^0 lam^1
+Generated values:
+-----
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
+-----
+UL (Here (True, (True, True)))
diff --git a/tests/derivation/least-effort/run/specialise/07-0 list-lookup/run b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-0 list-lookup/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/DerivedGen.idr b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/DerivedGen.idr
new file mode 100644
index 000000000..44b38f1f0
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/DerivedGen.idr	
@@ -0,0 +1,42 @@
+module DerivedGen
+
+import RunDerivedGen
+
+import public Data.Fin
+import Data.Fuel
+import Data.String
+import Data.Vect
+import public Data.Vect.AtIndex
+
+import Decidable.Equality
+
+import Deriving.DepTyCheck.Gen
+
+%language ElabReflection
+
+%default total
+
+public export
+Regs : Nat -> Type
+Regs n = Vect n $ Maybe Bool
+
+public export
+RegIsType : Fin r -> Bool -> Regs r -> Type
+RegIsType fn t rs = AtIndex fn rs (Just t)
+
+public export
+data SimpleExpr : Regs r -> Bool -> Type where
+  Read    : (idx : Fin r) -> RegIsType idx t regs => SimpleExpr regs t
+
+Show (AtIndex f v t) where
+  showPrec d $ Here = "Here"
+  showPrec d $ There x = showCon d "There" $ showArg x
+
+Show (SimpleExpr regs b) where
+  showPrec d $ Read idx @{rit} = showCon d "Read" $ showArg idx ++ showArg "@{\{show rit}}"
+
+checkedGen : Fuel -> (r : Nat) -> (t : Bool) -> Gen MaybeEmpty (a : Regs r ** SimpleExpr a t)
+checkedGen = deriveGen
+
+main : IO Unit
+main = runGs [ G (\f => checkedGen f 3 True) ]
diff --git a/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/RunDerivedGen.idr b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/RunDerivedGen.idr
new file mode 120000
index 000000000..2b18cc56c
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/RunDerivedGen.idr	
@@ -0,0 +1 @@
+../_common/RunDerivedGen.idr
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/derive.ipkg b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/derive.ipkg
new file mode 120000
index 000000000..ff0da46fe
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/derive.ipkg	
@@ -0,0 +1 @@
+../_common/derive.ipkg
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/expected b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/expected
new file mode 100644
index 000000000..0edcf41ee
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/expected	
@@ -0,0 +1,27 @@
+1/2: Building RunDerivedGen (RunDerivedGen.idr)
+2/2: Building DerivedGen (DerivedGen.idr)
+LOG deptycheck.util.specialisation:10: Data.Vect.AtIndex.AtIndex[0(type), 1(n), 4(x)] Declared specialised type DerivedGen.AtIndex^2737362274073714525.AtIndex^2737362274073714525: Data.Vect.AtIndex.AtIndex {type = Prelude.Types.Maybe Prelude.Basics.Bool} {n = lam^0} lam^1 lam^2 lam^3
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[0(len), 1(elem)] Declared specialised type DerivedGen.Vect^15780912604163783186.Vect^15780912604163783186: Data.Vect.Vect lam^0 (Prelude.Types.Maybe Prelude.Basics.Bool)
+LOG deptycheck.util.specialisation:10: Prelude.Types.Maybe[0(ty)] Declared specialised type DerivedGen.Maybe^2151327891283438926.Maybe^2151327891283438926: Prelude.Types.Maybe Prelude.Basics.Bool
+Generated values:
+-----
+-----
+([Just True, Nothing, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Nothing, Just False, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Just False, Just True, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Nothing, Just False, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Just False, Just True, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Nothing, Just True, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Nothing, Just False, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Nothing, Nothing, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Nothing, Nothing, Just True] ** Read 2 "@{There (There Here)}")
+-----
+([Just True, Nothing, Just False] ** Read 0 "@{Here}")
diff --git a/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/run b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/07-1 vect-indexed-multargspec/run	
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/least-effort/run/specialise/_common b/tests/derivation/least-effort/run/specialise/_common
new file mode 120000
index 000000000..3342f309f
--- /dev/null
+++ b/tests/derivation/least-effort/run/specialise/_common
@@ -0,0 +1 @@
+../../../_common
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/_common/Shared.idr b/tests/derivation/utils/specialise-if-needed/_common/Shared.idr
new file mode 100644
index 000000000..6938cbaae
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/_common/Shared.idr
@@ -0,0 +1,116 @@
+module Shared
+
+import public Control.Monad.Writer
+import public Control.Monad.Either
+import public Deriving.DepTyCheck.Util.Specialisation
+import public Deriving.DepTyCheck.Gen.ConsRecs
+import public Language.Reflection.Unify
+
+%language ElabReflection
+
+public export
+record CallGen where
+  constructor MkCallGen
+  sig : GenSignature
+  fuel : TTImp
+  givens : Vect sig.givenParams.size TTImp
+
+export
+[PrintDC]
+Monad m => Elaboration m => DerivationClosure m where
+  callGen sig fuel params = do
+    logPoint Warning "deptycheck.test.utils.specialise" [sig] "CallGen params: \{show params}"
+    pure (`(_), Nothing)
+
+export
+[WriterDC]
+Monad m => Elaboration m => MonadWriter (Maybe CallGen) m => DerivationClosure m where
+  callGen sig fuel params = do
+    tell $ Just $ MkCallGen sig fuel params
+    pure (`(?dc_return), Nothing)
+
+export
+queryVar : Elaboration m => TTImp -> m TTImp
+queryVar t@(IVar fc n) = do
+  getType n >>= pure . \case
+    (n, _) :: [] => IVar fc n
+    _            => t
+queryVar t = pure t
+
+export
+expandNames : Elaboration m => TTImp -> m TTImp
+expandNames = mapMTTImp queryVar
+
+export
+runSIN : Elaboration m => Maybe NamesInfoInTypes -> Bool -> TTImp -> m ()
+runSIN namesInfo declareSpec e = do
+  e <- expandNames e
+  logPoint Warning "deptycheck.test.utils.specialise" [] "Expanded e: \{show e}"
+  MkNS nsNames <- provideNS
+
+  let modName : Name -> Name
+      modName n = NS (MkNS $ show n :: nsNames) n
+
+  namesInfo : NamesInfoInTypes <-
+    case namesInfo of
+      Nothing    => getNamesInfoInTypes' e
+      Just nInfo => getNamesInfoInTypes' e <&> (<+> nInfo)
+  -- logPoint Warning "deptycheck.test.utils.specialise" [] "Types in namesInfo: \{show $ keys knownTypes}"
+
+  let (IVar _ tn, rs) = unAppAny e
+    | _ => fail "Failed to extract type name from invocation"
+  let Just ti = lookupType tn
+    | _ => fail "Failed to get type info"
+  let Yes atin = areAllTyArgsNamed ti
+    | No _ => fail "Type info has unnamed arguments"
+  let True = length ti.args == length rs
+    | _ => fail "Not all arguments have been given parameters"
+  let filtered = filter ((`(_) /=) . snd) $ zip (withIndex ti.args) $ map getExpr rs
+  let givenSet = SortedSet.fromList $ (fst . fst) <$> filtered
+  let givenVals = formGivenVals (Vect.fromList (Prelude.toList givenSet)) $ snd <$> filtered
+  let dc = PrintDC @{%search}
+
+  _ <- getConsRecs
+  r <- specialiseIfNeeded (MkGenSignature ti givenSet) `(?fuel) givenVals
+  case r of
+    Nothing => logMsg "" 0 "sIN returned nothing."
+    Just _ => pure ()
+
+export
+runSIN' :
+  Elaboration m =>
+  MonadWriter (Maybe CallGen) m =>
+  Maybe NamesInfoInTypes -> Bool -> TTImp -> m $ Maybe TTImp
+runSIN' namesInfo declareSpec e = do
+  e <- expandNames e
+  logPoint Warning "deptycheck.test.utils.specialise" [] "Expanded e: \{show e}"
+  MkNS nsNames <- provideNS
+
+  let modName : Name -> Name
+      modName n = NS (MkNS $ show n :: nsNames) n
+
+  namesInfo : NamesInfoInTypes <-
+    case namesInfo of
+      Nothing    => getNamesInfoInTypes' e
+      Just nInfo => getNamesInfoInTypes' e <&> (<+> nInfo)
+
+  let (IVar _ tn, rs) = unApp e
+    | _ => fail "Failed to extract type name from invocation"
+  let Just ti = lookupType tn
+    | _ => fail "Failed to get type info"
+  let Yes atin = areAllTyArgsNamed ti
+    | No _ => fail "Type info has unnamed arguments"
+  let filtered = filter ((`(_) /=) . snd) $ zip (withIndex ti.args) rs
+  let givenSet = SortedSet.fromList $ (fst . fst) <$> filtered
+  let givenVals = formGivenVals (Vect.fromList (Prelude.toList givenSet)) $ snd <$> filtered
+  let dc = WriterDC @{%search}
+
+  _ <- getConsRecs
+  specialiseIfNeeded (MkGenSignature ti givenSet) `(?fuel) givenVals
+
+export
+runSIN'' :
+  Elaboration m =>
+  Maybe NamesInfoInTypes -> Bool -> TTImp -> m (Maybe TTImp, Maybe CallGen)
+runSIN'' namesInfo declareSpec e =
+  runWriterT {w=Maybe CallGen} {m} $ runSIN' namesInfo declareSpec e
diff --git a/tests/derivation/utils/specialise-if-needed/_common/run b/tests/derivation/utils/specialise-if-needed/_common/run
new file mode 100644
index 000000000..dcee849a3
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/_common/run
@@ -0,0 +1,8 @@
+rm -rf build
+
+NAMES_CLEANER="$(dirname "$(dirname "$(realpath "$1")")")"/.clean-names
+
+flock "$1" pack -q install-deps test.ipkg && \
+idris2 --check --no-color --console-width 0 --no-banner --find-ipkg Test.idr | awk -f $NAMES_CLEANER
+
+rm -rf build
diff --git a/tests/derivation/utils/specialise-if-needed/_common/test.ipkg b/tests/derivation/utils/specialise-if-needed/_common/test.ipkg
new file mode 100644
index 000000000..5feb1f608
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/_common/test.ipkg
@@ -0,0 +1,3 @@
+package test
+
+depends = deptycheck
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/Shared.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/Shared.idr
new file mode 120000
index 000000000..6401061db
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/Shared.idr
@@ -0,0 +1 @@
+../_common/Shared.idr
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/Test.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/Test.idr
new file mode 100644
index 000000000..419fef3f3
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/Test.idr
@@ -0,0 +1,9 @@
+module Test
+
+import Shared
+
+%language ElabReflection
+
+%logging "deptycheck.util.specialisation" 20
+
+%runElab runSIN Nothing True `(Vect _ Nat)
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/expected b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/expected
new file mode 100644
index 000000000..4b9a15aeb
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/expected
@@ -0,0 +1,14 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Data.Vect.Vect _ Prelude.Types.Nat
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] Checking specialisation need for [Prelude.Types.Nat]...
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] len No given value, passing through
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] (elem := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] Task before normalisation: \ lam^0 => Data.Vect.Vect lam^0 Prelude.Types.Nat
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] NormaliseTask returned: lambdaTy = (lam^0 : Prelude.Types.Nat) -> Type;
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)]                         lambdaBody = \ lam^0 => Data.Vect.Vect lam^0 Prelude.Types.Nat;
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] Specialised type name: Vect^9686363643684445030.Vect^9686363643684445030
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] Specialised type not found, deriving...
+LOG deptycheck.util.specialisation:20: Data.Vect.Vect[1(elem)] Derived Test.Vect^9686363643684445030.Vect^9686363643684445030
+LOG deptycheck.util.specialisation:10: Data.Vect.Vect[1(elem)] Declared specialised type Test.Vect^9686363643684445030.Vect^9686363643684445030: Data.Vect.Vect lam^0 Prelude.Types.Nat
+LOG deptycheck.test.utils.specialise:0: Test.Vect^9686363643684445030.Vect^9686363643684445030[] CallGen params: []
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/run b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/run
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/test.ipkg b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/test.ipkg
new file mode 120000
index 000000000..7297aae9f
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-001/test.ipkg
@@ -0,0 +1 @@
+../_common/test.ipkg
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/Shared.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/Shared.idr
new file mode 120000
index 000000000..6401061db
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/Shared.idr
@@ -0,0 +1 @@
+../_common/Shared.idr
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/Test.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/Test.idr
new file mode 100644
index 000000000..0ac5590dc
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/Test.idr
@@ -0,0 +1,13 @@
+module Test
+
+import Shared
+
+%language ElabReflection
+
+%logging "deptycheck.util.specialisation" 20
+
+data X : (t : Type) -> (t -> Nat) -> Type where
+
+data Y = MkY (X Nat S)
+
+%runElab runSIN Nothing True `(X Nat S)
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/expected b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/expected
new file mode 100644
index 000000000..9c80a28b8
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/expected
@@ -0,0 +1,14 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Test.X Prelude.Types.Nat Prelude.Types.S
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Checking specialisation need for [Prelude.Types.Nat, Prelude.Types.S]...
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] (t := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] ({arg:1} := Prelude.Types.S) Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Task before normalisation: \ lam^0 => Test.X Prelude.Types.Nat lam^0
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] NormaliseTask returned: lambdaTy = (lam^0 : ({arg:2} : Prelude.Types.Nat) -> Prelude.Types.Nat) -> Type;
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1]                         lambdaBody = \ lam^0 => Test.X Prelude.Types.Nat lam^0;
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Specialised type name: X^17811957646955735153.X^17811957646955735153
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Specialised type not found, deriving...
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Derived Test.X^17811957646955735153.X^17811957646955735153
+LOG deptycheck.util.specialisation:10: Test.X[0(t), 1] Declared specialised type Test.X^17811957646955735153.X^17811957646955735153: Test.X Prelude.Types.Nat lam^0
+LOG deptycheck.test.utils.specialise:0: Test.X^17811957646955735153.X^17811957646955735153[0(fv^X^17811957646955735153.X^17811957646955735153^lam^0)] CallGen params: [Prelude.Types.S]
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/run b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/run
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/test.ipkg b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/test.ipkg
new file mode 120000
index 000000000..7297aae9f
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-002/test.ipkg
@@ -0,0 +1 @@
+../_common/test.ipkg
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/Shared.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/Shared.idr
new file mode 120000
index 000000000..6401061db
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/Shared.idr
@@ -0,0 +1 @@
+../_common/Shared.idr
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/Test.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/Test.idr
new file mode 100644
index 000000000..079786871
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/Test.idr
@@ -0,0 +1,15 @@
+module Test
+
+import Data.Fin
+import Shared
+
+%language ElabReflection
+
+%logging "deptycheck.util.specialisation" 20
+
+
+data X : (t : Type) -> (t -> Type) -> Type where
+
+data Y = MkY (X Nat Fin)
+
+%runElab runSIN Nothing True `(X Nat Fin)
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/expected b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/expected
new file mode 100644
index 000000000..9215a3913
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/expected
@@ -0,0 +1,14 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Test.X Prelude.Types.Nat Data.Fin.Fin
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Checking specialisation need for [Prelude.Types.Nat, Data.Fin.Fin]...
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] (t := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] ({arg:1} := Data.Fin.Fin) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Task before normalisation: Test.X Prelude.Types.Nat Data.Fin.Fin
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] NormaliseTask returned: lambdaTy = Type;
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1]                         lambdaBody = Test.X Prelude.Types.Nat Data.Fin.Fin;
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Specialised type name: X^8135581006587252120.X^8135581006587252120
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Specialised type not found, deriving...
+LOG deptycheck.util.specialisation:20: Test.X[0(t), 1] Derived Test.X^8135581006587252120.X^8135581006587252120
+LOG deptycheck.util.specialisation:10: Test.X[0(t), 1] Declared specialised type Test.X^8135581006587252120.X^8135581006587252120: Test.X Prelude.Types.Nat Data.Fin.Fin
+LOG deptycheck.test.utils.specialise:0: Test.X^8135581006587252120.X^8135581006587252120[] CallGen params: []
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/run b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/run
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/test.ipkg b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/test.ipkg
new file mode 120000
index 000000000..7297aae9f
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-003/test.ipkg
@@ -0,0 +1 @@
+../_common/test.ipkg
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/Shared.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/Shared.idr
new file mode 120000
index 000000000..6401061db
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/Shared.idr
@@ -0,0 +1 @@
+../_common/Shared.idr
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/Test.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/Test.idr
new file mode 100644
index 000000000..0906ed2e6
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/Test.idr
@@ -0,0 +1,28 @@
+module Test
+
+import Data.Fin
+import Shared
+
+%language ElabReflection
+
+%logging "deptycheck.util.specialisation" 20
+
+data X : (f : Nat -> Type) -> (n : Nat) -> (f n -> Nat) -> Type where
+
+Nt : Nat -> Type
+Nt 0 = Nat
+Nt _ = List Nat
+
+data Y : (a -> Nat) -> Type -> Type where
+
+Nn : List Nat -> Nat
+
+data Z = MkZ (Y Nn (X Nt 5 Nn))
+
+%runElab runSIN Nothing True `(Y {a=Nat} Nn (X Nt 5 Nn))
+
+Nn' : Fin 5 -> Nat
+
+data Z' = MkZ' (Y Nn' (X Fin 5 Nn'))
+
+%runElab runSIN Nothing True `(Y {a=Nat} Nn' (X Fin 5 Nn'))
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/expected b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/expected
new file mode 100644
index 000000000..c02213260
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/expected
@@ -0,0 +1,34 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Test.Y {a = Prelude.Types.Nat} Test.Nn (Test.X Test.Nt (fromInteger 5) Test.Nn)
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Checking specialisation need for [Prelude.Types.Nat, Test.Nn, Test.X Test.Nt (fromInteger 5) Test.Nn]...
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] (a := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] ({arg:1} := Test.Nn) Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] ({arg:2} := Test.X Test.Nt (fromInteger 5) Test.Nn) Given a type invocation, traversing arguments: [f, n, {arg:3}]
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] (f := Test.Nt) Given a non-global type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] (n := fromInteger 5) Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] ({arg:3} := Test.Nn) Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Task before normalisation: \ lam^0 => \ lam^1 => \ lam^2 => \ lam^3 => Test.Y {a = Prelude.Types.Nat} lam^0 (Test.X lam^1 lam^2 lam^3)
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] NormaliseTask returned: lambdaTy = (lam^0 : ({arg:4} : Prelude.Types.Nat) -> Prelude.Types.Nat) -> (lam^1 : ({arg:5} : Prelude.Types.Nat) -> Type) -> (lam^2 : Prelude.Types.Nat) -> (lam^3 : ({arg:6} : lam^1 lam^2) -> Prelude.Types.Nat) -> Type;
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2]                         lambdaBody = \ lam^0 => \ lam^1 => \ lam^2 => \ lam^3 => Test.Y {a = Prelude.Types.Nat} lam^0 (Test.X lam^1 lam^2 lam^3);
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Specialised type name: Y^17791941975642973451.Y^17791941975642973451
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Specialised type not found, deriving...
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Derived Test.Y^17791941975642973451.Y^17791941975642973451
+LOG deptycheck.util.specialisation:10: Test.Y[0(a), 1, 2] Declared specialised type Test.Y^17791941975642973451.Y^17791941975642973451: Test.Y {a = Prelude.Types.Nat} lam^0 (Test.X lam^1 lam^2 lam^3)
+LOG deptycheck.test.utils.specialise:0: Test.Y^17791941975642973451.Y^17791941975642973451[0(fv^Y^17791941975642973451.Y^17791941975642973451^lam^0), 1(fv^Y^17791941975642973451.Y^17791941975642973451^lam^1), 2(fv^Y^17791941975642973451.Y^17791941975642973451^lam^2), 3(fv^Y^17791941975642973451.Y^17791941975642973451^lam^3)] CallGen params: [Test.Nn, Test.Nt, fromInteger 5, Test.Nn]
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Test.Y {a = Prelude.Types.Nat} Test.Nn' (Test.X Data.Fin.Fin (fromInteger 5) Test.Nn')
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Checking specialisation need for [Prelude.Types.Nat, Test.Nn', Test.X Data.Fin.Fin (fromInteger 5) Test.Nn']...
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] (a := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] ({arg:1} := Test.Nn') Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] ({arg:2} := Test.X Data.Fin.Fin (fromInteger 5) Test.Nn') Given a type invocation, traversing arguments: [f, n, {arg:3}]
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] (f := Data.Fin.Fin) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] (n := fromInteger 5) Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] ({arg:3} := Test.Nn') Given a non-type expr, passing through
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Task before normalisation: \ lam^0 => \ lam^1 => \ lam^2 => Test.Y {a = Prelude.Types.Nat} lam^0 (Test.X Data.Fin.Fin lam^1 lam^2)
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] NormaliseTask returned: lambdaTy = (lam^0 : ({arg:4} : Prelude.Types.Nat) -> Prelude.Types.Nat) -> (lam^1 : Prelude.Types.Nat) -> (lam^2 : ({arg:6} : Data.Fin.Fin lam^1) -> Prelude.Types.Nat) -> Type;
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2]                         lambdaBody = \ lam^0 => \ lam^1 => \ lam^2 => Test.Y {a = Prelude.Types.Nat} lam^0 (Test.X Data.Fin.Fin lam^1 lam^2);
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Specialised type name: Y^15100848304045734396.Y^15100848304045734396
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Specialised type not found, deriving...
+LOG deptycheck.util.specialisation:20: Test.Y[0(a), 1, 2] Derived Test.Y^15100848304045734396.Y^15100848304045734396
+LOG deptycheck.util.specialisation:10: Test.Y[0(a), 1, 2] Declared specialised type Test.Y^15100848304045734396.Y^15100848304045734396: Test.Y {a = Prelude.Types.Nat} lam^0 (Test.X Data.Fin.Fin lam^1 lam^2)
+LOG deptycheck.test.utils.specialise:0: Test.Y^15100848304045734396.Y^15100848304045734396[0(fv^Y^15100848304045734396.Y^15100848304045734396^lam^0), 1(fv^Y^15100848304045734396.Y^15100848304045734396^lam^1), 2(fv^Y^15100848304045734396.Y^15100848304045734396^lam^2)] CallGen params: [Test.Nn', fromInteger 5, Test.Nn']
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/run b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/run
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/test.ipkg b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/test.ipkg
new file mode 120000
index 000000000..7297aae9f
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-004/test.ipkg
@@ -0,0 +1 @@
+../_common/test.ipkg
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/Shared.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/Shared.idr
new file mode 120000
index 000000000..6401061db
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/Shared.idr
@@ -0,0 +1 @@
+../_common/Shared.idr
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/Test.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/Test.idr
new file mode 100644
index 000000000..f76c7000b
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/Test.idr
@@ -0,0 +1,29 @@
+module Test
+
+import Data.Fin
+import Shared
+
+%language ElabReflection
+
+%logging "deptycheck.util.specialisation" 20
+
+
+%runElab do
+  (Just ti, _) <- runSIN'' Nothing False `(List Nat)
+    | _  => fail "Didn't generate a specialised type!"
+  logMsg "" 0 $ show ti.name
+  specNIIT <- getNamesInfoInTypes ti
+  logMsg "" 0 $ show $ keys $ knownTypes
+  runSIN (Just specNIIT) False `(List Nat)
+
+-- specRes : Maybe (TTImp, TypeInfo)
+-- specRes = %runElab runSIN' Nothing True `(List Nat)
+--
+
+-- specNIIT : NamesInfoInTypes
+-- specNIIT = %runElab do
+--   let Just (_, ti) = specRes
+--     | _ => fail "Didn't find specialised type!"
+--   getNamesInfoInTypes ti
+--
+-- %runElab runSIN (Just specNIIT) False `(List Nat)
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/dont-run b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/dont-run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/dont-run
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/expected b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/expected
new file mode 100644
index 000000000..ebc7eb350
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/expected
@@ -0,0 +1,23 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Checking specialisation need for [Prelude.Types.Nat]...
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] ({arg:1} := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Task before normalisation: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] NormaliseTask returned: lambdaTy = Type;
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0]                         lambdaBody = Prelude.Basics.List Prelude.Types.Nat;
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Specialised type name: List^4779069909474151191.List^4779069909474151191
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Specialised type not found, deriving...
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Derived Test.List^4779069909474151191.List^4779069909474151191
+LOG deptycheck.util.specialisation:10: Prelude.Basics.List[0] Declared specialised type Test.List^4779069909474151191.List^4779069909474151191: Prelude.Basics.List Prelude.Types.Nat
+LOG 0: Test.List^4779069909474151191.List^4779069909474151191
+LOG 0: [Prelude.Types.Nat, Test.List^4779069909474151191.List^4779069909474151191]
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Checking specialisation need for [Prelude.Types.Nat]...
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] ({arg:1} := Prelude.Types.Nat) Given a type invocation w/o arguments, specialising
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Task before normalisation: Prelude.Basics.List Prelude.Types.Nat
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] NormaliseTask returned: lambdaTy = Type;
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0]                         lambdaBody = Prelude.Basics.List Prelude.Types.Nat;
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Specialised type name: List^4779069909474151191.List^4779069909474151191
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Found Test.List^4779069909474151191.List^4779069909474151191
+LOG deptycheck.test.utils.specialise:0: Test.List^4779069909474151191.List^4779069909474151191[] CallGen params: []
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/test.ipkg b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/test.ipkg
new file mode 120000
index 000000000..7297aae9f
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-005/test.ipkg
@@ -0,0 +1 @@
+../_common/test.ipkg
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/Shared.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/Shared.idr
new file mode 120000
index 000000000..6401061db
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/Shared.idr
@@ -0,0 +1 @@
+../_common/Shared.idr
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/Test.idr b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/Test.idr
new file mode 100644
index 000000000..daccb1be4
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/Test.idr
@@ -0,0 +1,14 @@
+module Test
+
+import Data.Fin
+import Shared
+
+%language ElabReflection
+
+%logging "deptycheck.util.specialisation" 20
+
+
+%runElab do
+  (Nothing, _) <- runSIN'' Nothing False `(List a)
+    | _ => fail "List[0(a)] should not lead to specialisation!"
+  pure ()
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/expected b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/expected
new file mode 100644
index 000000000..332a440ff
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/expected
@@ -0,0 +1,5 @@
+1/2: Building Shared (Shared.idr)
+2/2: Building Test (Test.idr)
+LOG deptycheck.test.utils.specialise:0:  Expanded e: Prelude.Basics.List a
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Checking specialisation need for [a]...
+LOG deptycheck.util.specialisation:20: Prelude.Basics.List[0] Not found any type arguments that can be specialised upon, specialisation impossible.
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/run b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/run
new file mode 120000
index 000000000..805165988
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/run
@@ -0,0 +1 @@
+../_common/run
\ No newline at end of file
diff --git a/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/test.ipkg b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/test.ipkg
new file mode 120000
index 000000000..7297aae9f
--- /dev/null
+++ b/tests/derivation/utils/specialise-if-needed/spec-if-needed-006/test.ipkg
@@ -0,0 +1 @@
+../_common/test.ipkg
\ No newline at end of file