diff --git a/Cookbook/Essential/Common.hs b/Cookbook/Essential/Common.hs
--- a/Cookbook/Essential/Common.hs
+++ b/Cookbook/Essential/Common.hs
@@ -43,7 +43,13 @@
   where rev [] = []
         rev (x:xs) = rev xs ++ [x]
 
+-- | After a certain number of an element, return the list.
 afterX :: (Eq a) => [a] -> a -> Int -> [a]
 afterX (x:xs) c t
   | t == 0 = x:xs
   | otherwise = if x == c then afterX xs c (pred t) else afterX xs c t
+
+-- | Internal implementation of "intersperse".
+iSp :: [a] -> a -> [a]
+iSp [] _ = []
+iSp (x:xs) c = ([x] ++ [c]) ++  iSp xs c
diff --git a/Cookbook/Essential/Continuous.hs b/Cookbook/Essential/Continuous.hs
--- a/Cookbook/Essential/Continuous.hs
+++ b/Cookbook/Essential/Continuous.hs
@@ -21,13 +21,13 @@
 
 -- | Classifies items that can be modified by either a list or item.
 class Continuous list part where
-  
+
   -- | Returns all elements after part.
   after :: list -> part -> list
 
   -- | Returns all elements after part.
   before :: list -> part -> list
-  
+
   -- | Removes part from the list.
   delete :: list -> part -> list
 
@@ -35,7 +35,7 @@
   after x c   = tail $ Br.removeBreak (/=c) x
   before x c  = Br.filterBreak        (/=c) x
   delete x c  = filter                (/=c) x
-  
+
 instance (Eq a) => Continuous [a] [a] where
   after [] _ = []
   after x c  = if Ac.isBefore x c then Cm.sub x (length c) else after (tail x) c
@@ -48,7 +48,7 @@
 
 -- | Classifies information which can be split by a tupple.
 class Splicable a b where
-  
+
   -- | Removes everything between the tupple's parameters, including the parameters themselves.
   splice :: a -> b -> a
 
@@ -60,19 +60,19 @@
 
 -- | Classifies data which can be replaced.
 class Replacable list repls where
-  
+
   -- | Replaces part of list.
   replace  :: list -> repls -> list
-  
+
 instance (Eq a) => Replacable [a] (a,a) where
   replace lst (on,tw) = map (\c -> if c == on then tw else c) lst
-  
+
 instance (Eq a) => Replacable [a] [(a,a)] where
   replace x c = Cm.apply (map (flip replace) c) x
-  
+
 instance (Eq a) => Replacable [a] ([a],[a]) where
   replace [] _ = []
-  replace lst (on,tw) 
+  replace lst (on,tw)
     | take (length on) lst == on = tw ++ replace (Cm.sub lst (length on)) (on,tw)
     | otherwise = head lst : replace (tail lst) (on,tw)
 
diff --git a/Cookbook/Ingredients/Lists/Encompass.hs b/Cookbook/Ingredients/Lists/Encompass.hs
--- a/Cookbook/Ingredients/Lists/Encompass.hs
+++ b/Cookbook/Ingredients/Lists/Encompass.hs
@@ -1,4 +1,9 @@
 module Cookbook.Ingredients.Lists.Encompass where
+
+import qualified Cookbook.Essential.Continuous         as Ct
+import qualified Cookbook.Essential.Common             as Cm
+import qualified Cookbook.Ingredients.Functional.Break as Br
+
 {- |
    Module      :   Cookbook.Ingredients.Lists.Encompass
    Copyright   :   (c) 2014 by Nate Pisarski
@@ -8,7 +13,6 @@
    Portability :   Portable (Cookbook)
 Encompass is a library for parsing that is stringent on scope. It supports scope monitoring on single sets of single elements in a list, but it does not need to be a string. 
 -}
-import qualified Cookbook.Essential.Continuous as Ct
 
 -- | Get the entire section of a list contained within the scope delimited by the parameters, even sub-scopes.
 encompassing :: (Eq a) => [a] -> (a,a) -> [a]
@@ -39,8 +43,39 @@
       | not $  f `elem` e && g `elem` e = [e]
       | otherwise = beforeEncompassing e (f,g) : splitEncompassing (afterEncompassing e (f,g)) (f,g)
 
+-- | There is a long story behind this function, and why it sucks. See ENN1 in the source.
+notEncompassedSplit :: (Eq a) => [a] -> (a,a) -> a -> [[a]]
+notEncompassedSplit [] _ _ = [] -- "b{c,d},e,{f:g,e:h}"
+notEncompassedSplit ls (sp1,sp2) sp = toGaps $ helper ls 0
+  where
+    helper [] _ = []
+    helper (x:xs) c
+      | x == sp1 && c >= 0 = (sp1: encompassing (x:xs) (sp1,sp2)) : helper (afterEncompassing xs (sp1,sp2)) (c + 1)
+      | x == sp2 && c <= 0 = [x] :  helper xs (c - 1)
+      | x == sp1 = [x] : helper xs (c+1)
+      | x == sp2 = [x] : helper xs (c - 1)
+      | x == sp && c > 0 = [x] : helper xs c
+      | x == sp && c <= 0 = [] : helper xs c
+      | otherwise = [x] : helper xs c
+
+toGaps :: (Eq a) => [[a]] -> [[a]]
+toGaps [] = []
+toGaps x
+  | [] `notElem` x = [Cm.flt x]
+  | otherwise = (Cm.flt (Br.filterBreak (\c -> c /= []) x)) : (toGaps $ tail (Br.removeBreak (\c -> c /= []) x))
+
 -- | Returns all of the elements inside of a scope.
 gatherEncompassing :: (Eq a) => [a] -> (a,a) -> [[a]]
-gatherEncompassing a (b,c)
+gatherEncompassing a (b,c) 
   | not $ b `elem` a && c `elem` a = []
   | otherwise = encompassing a (b,c) : gatherEncompassing (afterEncompassing a (b,c)) (b,c)
+
+-- [ENN1]
+-- This function is terrible. Bloody AWFUL. So, why include it? Because it works.
+-- the implementation of the function is hard to rework, so unfortunately it doesn't
+-- get much better than this. I've tried rereading it time and time again, and the
+-- details of how it works confuse me. Prior to making the function, I spent
+-- more than a month thinking about how it should work. After that didn't work
+-- I began to change variables and behaviors in a fit of rage, and it started
+-- to work. And don't question the helper function either. This is as good
+-- as it gets, ladies and gentlemen.
diff --git a/Cookbook/Project/Quill/Quill.hs b/Cookbook/Project/Quill/Quill.hs
--- a/Cookbook/Project/Quill/Quill.hs
+++ b/Cookbook/Project/Quill/Quill.hs
@@ -62,7 +62,7 @@
 
 -- | Removes an entire table from the database by name.
 removeTable :: [(String,[(String,String)])] -> String -> [(String,[(String,String)])]
-removeTable x c = [e | e@(d,_) <- x, d /= c]
+removeTable x c = [e | e@(d,_) <- x, d /= c] -- WOAH what does this do?
 
 -- | Removes a particular item from a table within a database.
 removeItem :: [(String,[(String,String)])] -> (String,String) -> [(String,[(String,String)])]
diff --git a/Cookbook/Recipes/Cline.hs b/Cookbook/Recipes/Cline.hs
--- a/Cookbook/Recipes/Cline.hs
+++ b/Cookbook/Recipes/Cline.hs
@@ -1,9 +1,10 @@
-module Cookbook.Recipes.Cline(parse,Cline(..),clineExtract) where
+module Cookbook.Recipes.Cline(parse,Cline(..),clineExtract,clArg) where
 
 import qualified  Cookbook.Essential.Continuous     as Ct
 import qualified  Cookbook.Essential.Common         as Cm
 import qualified  Cookbook.Ingredients.Lists.Modify as Md
 import qualified  Cookbook.Ingredients.Lists.Access as Ac
+import qualified  Cookbook.Recipes.Sanitize         as Sn
 
 {- |
    Module      :   Cookbook.Recipes.Cline
@@ -39,3 +40,9 @@
 -- | Parse a flat string into a list of Clines.
 parse :: String -> [Cline]
 parse =  clineExtract . (`Md.splitOn` ' ')
+
+-- Helpers
+
+-- | Cleans a command line argument. If it's not a number, it will add a couple of dashes in front of it.
+clArg :: String -> String
+clArg x = if '-' `notElem` x && Sn.notNumeral x then ("--" ++ x) else x
diff --git a/Cookbook/Recipes/Sanitize.hs b/Cookbook/Recipes/Sanitize.hs
--- a/Cookbook/Recipes/Sanitize.hs
+++ b/Cookbook/Recipes/Sanitize.hs
@@ -57,3 +57,11 @@
 -- | Removes all "symbols" from a string
 rmsymbols :: String -> String
 rmsymbols = (`blacklist` ['\\'..'`'])
+
+-- | Check to see if the string is a non-numeral
+notNumeral :: String -> Bool
+notNumeral x = all (\c -> c `elem` ['A'..'z']) x
+
+-- | Check to see if the string is numeral.
+numeral :: String -> Bool
+numeral x = all (\c -> c `notElem` ['A'..'z']) x
diff --git a/cookbook.cabal b/cookbook.cabal
--- a/cookbook.cabal
+++ b/cookbook.cabal
@@ -3,7 +3,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             2.2.0.0
+version:             2.2.1.0
 synopsis:	Tiered general-purpose libraries with domain-specific applications.
 description:		Cookbook is a line of libraries covering a wide variety of Haskell applications. Every application that I make, I add its functions to Cookbook, turning Cookbook into an all-encompassing general-purpose library over time. The claim-to-fame for the library is its use of overloaded typeclasses, called "Continuities". 
 license:             BSD3