     is found in the originalString otherwise FALSE. This search is not case sensitive.
     
     :param originalString
-            The original contents that is going to be searched
+    The original contents that is going to be searched
     :param stringToSearch
-            The specific contents to search for
+    The specific contents to search for
     :return
-            A Boolean of TRUE if found otherwise FALSE for not found
-    */
-    public class func search<T : Equatable>(originalString originalString: T, stringToSearch: T) -> Bool
+    A Boolean of TRUE if found otherwise FALSE for not found
+    */
+    public class func search<T : Equatable>(#originalString: T, var stringToSearch: T) -> Bool
     {
         return search(originalString: originalString, stringToSearch: stringToSearch, isCaseSensitive: false)
     }
     
     /*
-    The FuzzySearch.search method returns the number of timees found (Integer) of the 
+    The FuzzySearch.search method returns the number of timees found (Integer) of the
     set of characters to be searched within the original character set.
     
     :param originalString
-            The original contents that is going to be searched
+    The original contents that is going to be searched
     :param stringToSearch
-            The specific contents to search for
+    The specific contents to search for
     :return
-            A Boolean of TRUE if found otherwise FALSE for not found
-    */
-    public class func search<T : Equatable>(originalString originalString: T, stringToSearch: T) -> Int
+    A Boolean of TRUE if found otherwise FALSE for not found
+    */
+    public class func search<T : Equatable>(#originalString: T, var stringToSearch: T) -> Int
     {
         return search(originalString: originalString, stringToSearch: stringToSearch, isCaseSensitive: false)
     }
     
     /*
     The FuzzySearch.search method returns a Boolean of TRUE if the stringToSearch for
-    is found in the originalString otherwise FALSE. This search does search for case sensitive 
+    is found in the originalString otherwise FALSE. This search does search for case sensitive
     Strings by using a Boolean value to indicate what kind of search to use.
     
     :param originalString
-            The original contents that is going to be searched
+    The original contents that is going to be searched
     :param stringToSearch
-            The specific contents to search for
+    The specific contents to search for
     :param isCaseSensitive
-            A Boolean value to indicate whether to use case sensitive or case 
-            insensitive search parameters
+    A Boolean value to indicate whether to use case sensitive or case
+    insensitive search parameters
     :return
-            A Boolean of TRUE if found otherwise FALSE for not found
-    */
-    public class func search<T : Equatable>(originalString originalString: T, stringToSearch: T, isCaseSensitive: Bool) -> Bool
+    A Boolean of TRUE if found otherwise FALSE for not found
+    */
+    public class func search<T : Equatable>(#originalString: T, var stringToSearch: T, isCaseSensitive: Bool) -> Bool
     {
         /* Decipher if the String to be searched for is found */
-        let searchCount:Int = search(originalString: originalString, stringToSearch: stringToSearch, isCaseSensitive: isCaseSensitive)
+        var searchCount:Int = search(originalString: originalString, stringToSearch: stringToSearch, isCaseSensitive: isCaseSensitive)
         
         if searchCount > 0
         {

    approximately matches that String object
    
    :param originalString
            The original contents that is going to be searched
    :param stringToSearch
            The specific contents to search for
    :param isCaseSensitive
            A Boolean value to indicate whether to use case sensitive or case
            insensitive search parameters
    :return
           The Array of String(s) if any are found otherwise an empty Array of String(s)
    */

    public class func search(var originalString originalString: String, var stringToSearch: String, isCaseSensitive: Bool) -> [String]
    {
        /*
        Either String is empty return false
        */
        if originalString.characters.count == 0 || stringToSearch.characters.count == 0
        {
            return [String]()
        }

        /*
        Search the contents of the originalString to determine if the stringToSearch can be found or not
        */
        for charOut in tempOriginalString
        {
            for (indexIn, charIn) in enumerate(tempStringToSearch)
            {
                if indexIn == searchIndex
                {
                    if charOut==charIn
                    {
                        searchIndex++
                        if searchIndex==count(tempStringToSearch)
                        {
                            searchCount++
                            searchIndex = 0
