             return WordType.Adjective
         }
         
+        //Adverbs
+        if wordModifiers.contains(Keywords.adverb)
+        {
+            return WordType.Adverb
+        }
+        
         //Prepositions
-        if wordModifiers.contains(prepositionKeyword),
-           let declensionText = wordModifiers.second,
-           let declension = getDeclension(fromPreposition: declensionText)
-        {
+        if wordModifiers.contains(Keywords.preposition), let declensionText = wordModifiers.second
+        {
+            let declension = getDeclension(fromPreposition: declensionText)
             return WordType.Preposition(declension)
         }
         
         //Interjections
-        if wordModifiers.contains(interjectionKeyword)
+        if wordModifiers.contains(Keywords.interjection)
         {
             return WordType.Interjection
         }
         
         //Lastly, nouns
-        if wordModifiers.contains(nounKeyword),
-           let declensionText = conjugationOrDeclension.first,
-           let declension = getDeclension(from: declensionText)
-        {
+        if wordModifiers.contains(Keywords.noun), let declensionText = conjugationOrDeclension.first
+        {
+            let declension = getDeclension(from: declensionText)
             
-            if wordModifiers.contains(masculineKeyword)
+            if wordModifiers.contains(Keywords.masculine)
             {
                 return WordType.Noun(declension, .Male)
             }
-            else if wordModifiers.contains(feminineKeyword)
+            else if wordModifiers.contains(Keywords.feminine)
             {
                 return WordType.Noun(declension, .Female)
             }
-            else if wordModifiers.contains(neuterKeyword)
+            else if wordModifiers.contains(Keywords.neuter)
             {
                 return WordType.Noun(declension, .Neuter)
             }

        let wordModifiers = line =~ Regex.wordModifiers
        let conjugationOrDeclension = line =~ Regex.declension
        
        let verbKeyword = "V"
        let transitiveKeyword = "TRANS"
        let intransitiveKeyword = "INTRANS"
        let deponentKeyword = "DEP"
        let impersonalKeyword = "IMPERS"
        
        let nounKeyword = "N"
        let adjectiveKeyword = "ADJ"
        let feminineKeyword = "F"
        let masculineKeyword = "M"
        let neuterKeyword = "N"
        
        let prepositionKeyword = "PREP"
        let accusativeKeyword = "ACC"
        
        let interjectionKeyword = "INTERJ"
        
        
        
        //Verbs
        if wordModifiers.contains(verbKeyword),
           let conjugationText = conjugationOrDeclension.first,
           let conjugation = getConjugation(from: conjugationText)
        {
            
            if wordModifiers.contains(intransitiveKeyword)
            {
                return WordType.Verb(conjugation, .Intransitive)
            }
            else if wordModifiers.contains(transitiveKeyword)
            {
                return WordType.Verb(conjugation, .Transitive)
            }
            else if wordModifiers.contains(deponentKeyword)
            {
                return WordType.Verb(conjugation, .Deponent)
            }
            else if wordModifiers.contains(impersonalKeyword)
            {
                return WordType.Verb(conjugation, .Impersonal)
            }
            else
            {
                LOG.warn("Undetected Verb Type: \(wordModifiers)")
            }
        }

            case "5th" : return .Ablative
            case "6th" : return .Vocative
            case "7th" : return .Locative
            default :    return .Undeclined
        }
    }
    
    func getDeclension(fromPreposition text: String) -> Declension
    {
        switch text
        {
            case "ACC" : return .Accusative
            case "GEN" : return .Genitive
            case "ABL" : return .Ablative
            default :    return .Undeclined
        }
    }

}


//MARK: Dictionary keywords
private class Keywords
{
    static let verb = "V"
    static let transitive = "TRANS"
    static let intransitive = "INTRANS"
    static let deponent = "DEP"
    static let impersonal = "IMPERS"
    
    static let adverb = "ADV"
    
    static let noun = "N"
    static let adjective = "ADJ"
    static let feminine = "F"
    static let masculine = "M"
    static let neuter = "N"
    
    static let preposition = "PREP"
    static let accusative = "ACC"
    
    static let interjection = "INTERJ"
}
