diff --git a/Language_Cleaner.zip b/Language_Cleaner.zip
new file mode 100644
index 0000000..cfedccf
Binary files /dev/null and b/Language_Cleaner.zip differ
diff --git a/README.md b/README.md
index 25c56db..3ecf955 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,26 @@
 # calibre-plugin-language-cleaner
 Length list of regexes to "clean up" language in books.
+
+I wrote this plugin because I don't like reading vulgar language, but I like reading books with vulgar language in it :). Personally I find books much more enjoyable after being processed with this script. Obviously it is a personal set of filters, but I've done my best to make the changes sound as natural as possible, and after using it for years, I think it's pretty good.
+
+If you'd like to customize it to meet your preferences, you just need to go through the lines of cleaner.py and add or remove filters as needed. You'll probably need a pretty good mastery of regular expressions to write new ones unless there is a similar one existing already that you can tweak.
+
+== LIMITATIONS ==
+
+I am no expert at calibre, and I could not drum up much help on the support forums, so the integration is pretty weak. It only works on books that are being converted from epub, and only works during the conversion process.
+
+To install:
+* create a zip file with the three files: `cleaner.py`, `__init__.py`, and `plugin-import-name-language_clean_plugin.txt` called `Language_Cleaner.zip`. This command may help in Linux.
+`zip Language_Cleaner cleaner.py __init__.py plugin-import-name-language_clean_plugin.txt`
+* In calibre choose Preference -> Plugins -> Load plugin from file
+* Choose the zip you just created, and the plugin should show up under "File type plugins"
+
+To use:
+* Choose the book you'd like and make sure you have an epub format (so convert to epub if you don't already have that format)
+* Now do "Convert book" and choose to convert from Epub to Epub (or whatever destination format you want)
+* Wait until longer than usual job completes, due the very inefficient way this plugin works
+
+Secret debug tip:
+If there is a "c:/Scratch/calibre" folder on your Winodws machine (change `logdir` in `__init__.py` if you want), the plugin will write before and after versions of the book as plain text files. Sometimes it does two copies and only one has useful changes. If you'd like to see how it was changed, compare the two files. I use [WinMerge](http://winmerge.org/) and that works well.
+
+By the way, there is a strong layer of irony here -- if vulgar language offends you, you'll probably want to avoid actually looking in the `cleaner.py` file, as it is chock full of it :)
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000..67f6728
--- /dev/null
+++ b/__init__.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
+from __future__ import (unicode_literals, division, absolute_import,
+                        print_function, with_statement)
+logdir = "c:/Scratch/calibre"
+__license__   = 'GPL v3'
+__copyright__ = '2012, Jordan Anderson'
+__docformat__ = 'restructuredtext en'
+
+#from __future__ import with_statement
+import sys, os, time
+from calibre.customize import FileTypePlugin
+from optparse import OptionGroup, Option
+from calibre.ebooks.tweak import *
+from calibre_plugins.language_clean_plugin.cleaner import *
+from functools import partial
+import codecs, mimetypes
+
+class CleanerPlugin(FileTypePlugin):
+
+    name                = 'Language Cleaner' # Name of the plugin
+    description         = 'Replace naughty or offensive language with something more acceptable (to me at least), recovered version'
+    supported_platforms = ['windows', 'osx', 'linux'] # Platforms this plugin will run on
+    author              = 'Jordan Anderson' # The author of this plugin
+    version             = (1, 5, 2017)   # The version number of this plugin
+    file_types          = set(['epub']) # The file types that this plugin will be applied to
+    on_preprocess       = True # Run this plugin after conversion is complete
+    minimum_calibre_version = (0, 7, 53)
+
+    def run(self, path_to_ebook):
+        #print ("*"*60,"\n","you are in Language Cleaner")
+        #print ("*"*60,"\n")
+        ebook_file=path_to_ebook
+        fmt = ebook_file.rpartition('.')[-1].lower()
+        exploder, rebuilder = get_tools(fmt)
+        with TemporaryDirectory('_tweak_'+
+            os.path.basename(ebook_file).rpartition('.')[0]) as tdir:
+            #prints ("Relevant info:",tdir,fmt,ebook_file)
+            try:
+                opf = exploder(ebook_file, tdir)
+            except WorkerError as e:
+                prints('Failed to unpack', ebook_file)
+                prints(e.orig_tb)
+                raise SystemExit(1)
+            except Error as e:
+                prints(as_unicode(e), file=sys.stderr)
+                raise SystemExit(1)
+            #Debug
+            print ("Created tdir:",tdir,"and found opf",opf)
+            #print (os.popen("ll "+tdir).read())
+            #print ("OPF CONTENTS:")
+            #print (open(opf,'r').read())
+            #manipulate all of the files
+            opf = open(opf,'r').read().split('\n')
+            # first, assemble the entire text to evaluate context
+            text=""
+            for f in walk(tdir):
+              opf_line = [ii for ii in opf if os.path.basename(f).lower() in ii.lower()]
+              ftype = mimetypes.guess_type(f)[0]
+              if not ftype and "html" in f.split('.')[-1]:
+                  print('Non-text type %s for file %s but forcing text mode'%(ftype, f))
+                  ftype = 'text'
+              if not ftype:
+                  print('Non-text type %s for file %s'%(ftype, f))
+              elif opf_line and 'text' in ftype:
+                encodings = ['utf-8', 'windows-1252', 'windows-1250']
+                for e in encodings:
+                    try:
+                        text += codecs.open(f,'r',encoding=e).read()
+                    except UnicodeDecodeError:
+                        print('File %s: got unicode error with %s , trying different encoding' % (f,e))
+                    else:
+                        print('File %s: opening the file with encoding:  %s ' % (f,e))
+                        break  
+            replacement_list = language_check(text)
+            start_text=text
+            end_text=""
+            #Now do replacements on each file
+            for f in walk(tdir):
+              opf_line = [ii for ii in opf if os.path.basename(f).lower() in ii.lower()]
+              #Not sure what the correct way to determine which files should
+              # be edited. Seems like most are marked 'application/' in type
+              print ("File",f,"\nOPF line:\n",opf_line)
+              ftype = mimetypes.guess_type(f)[0]
+              if not ftype and "html" in f.split('.')[-1]:
+                  print('Non-text type %s for file %s but forcing text mode'%(ftype, f))
+                  ftype = 'text'
+              if not ftype:
+                  print('Non-text type %s for file %s'%(ftype, f))
+              elif opf_line and 'text' in ftype:
+                print ("Cleaning",f)
+                text = open(f,'r').read()
+                output = ""
+                for line in text.split("\n"):
+                  #Go through all elements of replacement_list
+                  for search,sub,pcase in replacement_list:
+                    if pcase: # Preserve case
+                      line = search.sub(partial(pcase,sub),line)
+                    else: # Don't preserve case
+                      line = search.sub(sub,line)
+                  output += line + "\n"
+                open(f,'w').write(output)
+                end_text += output
+            if start_text.replace('\n',"") == end_text.replace('\n',''):
+                print ("Language cleaner made no changes")
+            else:
+                if os.path.exists(logdir):
+                    open(logdir+os.sep+'%s_init.txt'%(os.path.basename(ebook_file)+str(time.time())),'w').write(start_text)
+                    open(logdir+os.sep+'%s_mod.txt'%(os.path.basename(ebook_file)+str(time.time())),'w').write(end_text)
+            prints('Rebuilding', ebook_file, 'please wait ...')
+            try:
+                rebuilder(tdir, ebook_file)
+            except WorkerError as e:
+                prints('Failed to rebuild', ebook_file)
+                prints(e.orig_tb)
+                raise SystemExit(1)
+            prints(ebook_file, 'successfully cleaned')
+
+        #print (path_to_ebook,ext,str(mi))
+        #print ("you are returning from Language Cleaner")
+        return ebook_file
+
+
diff --git a/cleaner.py b/cleaner.py
new file mode 100644
index 0000000..698a580
--- /dev/null
+++ b/cleaner.py
@@ -0,0 +1,479 @@
+#!/usr/bin/env python
+# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
+import os,sys,re
+#text = open('bad.txt').read()
+
+#Substitute requested word matching case of matched word
+def keep_case(sub,matchobj):
+  val = matchobj.group(0)
+  up_count = 0
+  if val.isupper():
+    sub = sub.upper()
+  else:
+    #Test first two to see if all uppercase
+    for ii in range(min(2,len(sub),len(val))):
+      if val[ii].isupper():
+        up_count += 1
+        sub = sub[:ii] + sub[ii].upper() + sub[ii+1:]
+    #Allow further uppercase only if all uppercase
+    for ii in range(min(len(sub),len(val))):
+      if up_count > 1:
+        up_count += 1
+        sub = sub[:ii] + sub[ii].upper() + sub[ii+1:]
+  return sub
+
+def first_case(sub,matchobj):
+  val = matchobj.group(0)
+  if val.isupper():
+    sub = sub.upper()
+  else:
+   try:
+    for ii in range(1):
+      if val[ii].isupper():
+        sub = sub[:ii] + sub[ii].upper() + sub[ii+1:]
+   except:
+     print "*"*60,"sub=",sub,"val=",val,"*"*60
+  return sub
+
+#Drop first match, match case of first and return second
+def drop_first_match(sub,matchobj):
+  drop = matchobj.group(1)
+  val = matchobj.group(2)
+  try:
+   for ii in range(len(drop)): #find first alpha in drop
+    if drop[ii].isalpha() :
+      if drop[ii].isupper(): #uppercase, so copy to val
+        for jj in range(len(val)): #find first alpha in val
+          if val[jj].isalpha():
+            val = val[:jj] + val[jj].upper() + val[jj+1:]
+            break
+      break
+  except:
+    print "*"*50, "error in drop_first_match"
+    print drop
+    print val
+    print str(sub)
+    print str(matchobj.groups())
+  return val
+
+# Prepare two lists for different meanings of ass
+dirty_a_list=[
+  #########################################
+  # dirtier ass
+  #########################################
+  #haul ass
+  (re.compile(r'\b(move|haul)\Wass\b',re.I),"move fast",keep_case),
+  #little ass
+  (re.compile(r'little\W?ass\b',re.I),"little donkey",keep_case),
+  (re.compile(r'little\W?asses\b',re.I),"little donkeys",keep_case),
+  #your/own/etc. ass
+  (re.compile(r'(?<=(.your|..own|...my|..our|..her|..his|.this|.that|..the|their|those|these|..its|..for)\W)ass\b',re.I),"rear",keep_case),
+  (re.compile(r'(?<=(.your|..own|...my|..our|..her|..his|.this|.that|..the|their|those|these|..its|..for)\W)asses\b',re.I),"rears",keep_case),
+  #asses
+  (re.compile(r'\basses\b',re.I),"rears",keep_case),
+  #ass
+  (re.compile(r'\ban\Wass\b',re.I),"a jerk",keep_case),
+  (re.compile(r'\bass\b',re.I),"rear",keep_case),
+  ]
+
+clean_a_list=[
+  #########################################
+  # cleaner ass
+  #########################################
+  #haul ass
+  (re.compile(r'\bhaul\Wass\b',re.I),"move fast",keep_case),
+  #asses
+  (re.compile(r'\basses\b',re.I),"donkeys",keep_case),
+  #ass
+  (re.compile(r'\ban Ass\b'),"a Donkey",False), #C.S. Lewis
+  (re.compile(r'\ban\Wass\b',re.I),"a donkey",keep_case),
+  (re.compile(r'(?<!in\W)\bass\b',re.I),"donkey",keep_case),
+  ]
+
+s_lord='(god|jesus(\W?christ)?|christ)'
+lord_list=[
+  #Thank God
+  (re.compile(r'thank( you\,?)? '+s_lord+r'\b',re.I),"thank goodness",first_case),
+  #My God
+  (re.compile(r'(?<!(..\bin|..\bis|..\bto|..\bof|from|..\bon)\W)my '+s_lord+r's?\b(?! \w)',re.I),"my goodness",first_case),
+  #Oh God
+  (re.compile(r'\boh\,? '+s_lord+r'\b',re.I),"oh goodness",first_case),
+  #Good God
+  (re.compile(r'\bgood '+s_lord+r'\b',re.I),"goodness",first_case),
+  #name of God
+  (re.compile(r'\bname of '+s_lord+r'\b',re.I),"world",first_case),
+  #In God's name
+  (re.compile(r'(?<=where\W)\bin\W'+s_lord+'\W*s name',re.U+re.I),"in the world",first_case),
+  (re.compile(r'\bin '+s_lord+'\W*s name',re.U+re.I),"for goodness sake",first_case),
+  #in God
+  (re.compile(r'\bin '+s_lord+r'\b',re.I),"in the lord",first_case),
+  #of God
+  #(re.compile(r'(?<!(.church|society|...time) )of '+s_lord+r'\b',re.I),"of heaven",first_case),
+  #to God
+  (re.compile(r'\bto '+s_lord+r'\b',re.I),"to heaven",first_case),
+  #by God
+  (re.compile(r'\bby '+s_lord+r'\b',re.I),"by the heavens",first_case),
+  #God knows (start of sentence, not start of sentence)
+  (re.compile(r'([^ ]|\. +)'+s_lord+' knows',re.I),r"\1Heaven knows",False),
+  (re.compile(r''+s_lord+' knows',re.I),"heaven knows",False),
+  #For God's sake
+  (re.compile(r'\bfor '+s_lord+'\W*s sake',re.U+re.I),"for goodness sake",first_case),
+  #Godforsaken
+  (re.compile(r'\b'+s_lord+'.?forsaken\b',re.I),"forsaken",keep_case),
+  #Godawful
+  (re.compile(r'\b'+s_lord+'.?awful\b',re.I),"forsaken",keep_case),
+  ]
+
+# Use if this book is likely to take Lord's name in vain
+vain_lord_list=[
+  (re.compile(r'thanked '+s_lord+r'\b',re.I),"thanked heaven",first_case),
+  (re.compile(r'(?<=([\.?!,]\W\W|..\"|”|“|.\W\W))'+s_lord+'s?(?=[\.,?!])',re.U+re.I),"goodness",keep_case),
+  #Jesus and/or Christ
+  (re.compile(r'(?<!of )\bjesus(\W?(christ|almighty))?',re.I),"goodness",first_case),
+  (re.compile(r'(?<!of )(?<!jesus )christ\b',re.I),"goodness",keep_case),
+  #God
+  #(re.compile(r'(?<![Oo][Ff] )\bG[Oo][Dd]\b(?! ([Bb][Ll][Ee][Ss][Ss]|[Ss][Aa][Vv][Ee]))'),"goodness",keep_case),
+  ]
+
+  
+# 3 element list: [search phrase, replace value, preserve case function]
+re_list = [
+  #########################################
+  ## Random stuff
+  #########################################
+  #Remove suggestive 'tits' with not suggestive belly
+  # don't do 'tit for tat', tit-tat-toe, or split tit-ular
+  (re.compile(r'\b[tT][iI][tT][sS]?\b(?! for)(?!-tat)(?!-ul)',re.I),'belly',keep_case),
+  #Slut is rude, replace with slightly better hussy
+  (re.compile(r'\bslut\b',re.I),'hussy',keep_case),
+  (re.compile(r'\bsluts\b',re.I),'hussies',keep_case),
+  #Change topless bar to just bar
+  (re.compile(r'topless\Wbar',re.I),'bar',keep_case),
+  #Replace whore with woman (not always a good replacement)
+  #(re.compile(r'\bwhore\b',re.I),'woman',keep_case),
+  #(re.compile(r'\bwhores\b',re.I),'women',keep_case),
+  #Whorehouse becomes brothel
+  (re.compile(r'whorehouse',re.I),'brothel',keep_case),
+  #Crap and crapper to 'use the toilet'
+  (re.compile(r'take\Wa\Wcrap(per)?',re.I),'use the toilet',keep_case),
+  (re.compile(r'\bcrapper',re.I),'toilet',keep_case),
+  #Crap and crapper to garbage
+  (re.compile(r'\bcrap\b',re.I),'garbage',keep_case),
+  (re.compile(r'\bcrapped\b',re.I),'wet',keep_case),
+  #Cock-up with mess-up
+  (re.compile(r'\bcock.?up\b',re.I),"mess up",keep_case),
+  #Cocksucker with sucker
+  (re.compile(r'\bcock.?(?=suc)',re.I),"",False),
+  #Cocker with idiot (but not cocker spaniel
+  (re.compile(r'\bcocker\b(?![ -]spani)',re.I),"idiot",keep_case),
+  #Cunt
+  (re.compile(r'\bcunt\b',re.I),'groin',keep_case),
+  #Replace goddammit and dammit with 'dang it'
+  (re.compile(r'([^\.?!] *) Goddam([mn])',re.I),r'\1 goddam\2',False),
+  (re.compile(r'(?:gods?)?dammit',re.I),'dang it',keep_case),
+  #########################################
+  ## Replace ass and its varieties (see specific lists above, dirty_a_list and clean_a_list)
+  #########################################
+  #smart ass
+  (re.compile(r'smart\W?ass\b',re.I),"smart aleck",keep_case),
+  (re.compile(r'smart\W?asses\b',re.I),"smart alecks",keep_case),
+  #kiss ass
+  (re.compile(r'kissin[^\s]\Wass(es)?\b',re.U+re.I),"kissing up",keep_case),
+  (re.compile(r'kiss.{1,6}ass(es)?\b',re.I),"fly a kite",keep_case),
+  #kick ass
+  (re.compile(r'kick\W?ass\b',re.I),"kick booty",keep_case),
+  (re.compile(r'kick\W?asses\b',re.I),"kick booties",keep_case),
+  #cover ... ass
+  (re.compile(r'(cover.{0,8} )ass\b',re.I),r"\1rear",False),
+  (re.compile(r'(cover.{0,8} )asses\b',re.I),r"\1rears",False),
+  #kick ... ass
+  (re.compile(r'(kick.{0,8} )ass\b',re.I),r"\1rear",False),
+  (re.compile(r'(kick.{0,8} )ass\b',re.I),r"\1rears",False),
+  #assed
+  (re.compile(r'\bassed\b',re.I),"ended",keep_case),
+  #jack/dumbass
+  (re.compile(r'(?<=bray like a )(jack|dumb)ass\b',re.I),"donkey",keep_case),
+  (re.compile(r'(jack|dumb)ass\b',re.I),"jerk",keep_case),
+  (re.compile(r'(jack|dumb)asses\b',re.I),"jerks",keep_case),
+  #asshole
+  (re.compile(r'an\Wasshole',re.I),"a jerk",keep_case),
+  (re.compile(r'asshole',re.I),"jerk",keep_case),
+  #horse's ass
+  (re.compile(r'horse[^\s]?s ?ass\b',re.U+re.I),"jerk",keep_case),
+  (re.compile(r'horse[^\s]?s ?asses\b',re.U+re.I),"jerks",keep_case),
+  #########################################
+  ## Replace damn and its varieties
+  #########################################
+  #I'll be damned
+  (re.compile(r'be(\W+)(?:gods? *)?damned',re.I),r'be\1darned',False),
+  #Give a damn
+  (re.compile(r'give(\W+.{0,10}?)a(\W+)(?:gods? *)?damn',re.I),'care',keep_case),
+  (re.compile(r'gives(\W+.{0,10}?)a(\W+)(?:gods? *)?damn',re.I),'cares',keep_case),
+  #Damn near
+  (re.compile(r'(?:gods? *)?damn(\W+)near',re.I),'nearly',keep_case),
+  #a damn. Worth a damn -> worth a cent (couldn't think of a better word)
+  (re.compile(r'((matters?|worth|of)\W+a\W+)(?:gods? *)?damn\b',re.I),r'\1cent',False),
+  #of the damned
+  (re.compile(r'(of\W*the\W*)(?:gods? *)?damned\b',re.I),r'\1cursed',False),
+  #Your damned word, a damn word, etc
+  (re.compile(r'(your|our|her|his|this|that|the|their|hose|these|for|so|some|one|one more|too)( +)(?:gods? *)?damn(?:ed)?\b(?!-)',re.I),r'\1',False),
+  #a damn
+  (re.compile(r'(?<=\b[aA] )(?:gods? *)?damn(?:ed)',re.I),'darn',keep_case),
+  #damned good, damn sure, etc (Clancy's favorites)
+  (re.compile(r'\b((?:gods? *)?damn(?:ed))(?:\W+)(sure|near|sight|good|much|hard|easy|big|little|glad|clever|mess|smart|fine|fool|right|thing|much|shame|nice|mean|bad|lucky|late|important)',re.I),'',drop_first_match),
+  (re.compile(r'\b((?:gods? *)?damn(?:ed))(?:\W+)well',re.I),'darn well',keep_case),
+  #Religious damning
+  (re.compile(r'\b(?:gods? *)?damned',re.I),'cursed',keep_case),
+  (re.compile(r'\b(?:gods? *)?damndest',re.I),'very best',keep_case),
+  (re.compile(r'\b(?:gods? *)?damning',re.I),'condemning',keep_case),
+  (re.compile(r'\b(?:gods? *)?damnable',re.I),'condemning',keep_case),
+  (re.compile(r'\b(?:gods? *)?damnably',re.I),'cursedly',keep_case),
+  (re.compile(r'\b(?:gods? *)?damnatory',re.I),'condemning',keep_case),
+  (re.compile(r'\b(?:gods? *)?damnation',re.I),'condemnation',keep_case),
+  #damn it
+  (re.compile(r', (?:gods? *)?damn it(?: all)?',re.I),'',keep_case),
+  (re.compile(r'((?:gods? *)?damn it(?: all)?, +)(.)',re.I),'',drop_first_match),
+  #a damn something, like "a damn nuisance"
+  (re.compile(r'\ba(\W+)(?:gods? *)?damn',re.I),r'a\1blasted',False),
+  #damn you/his/her/etc
+  (re.compile(r'\b(?:gods? *)?damn you to hell',re.I),'curse you',keep_case),
+  (re.compile(r'\b(?:gods? *)?damn(?= (him|his|her|you|next|the|you))',re.I),'curse',keep_case),
+  #Word by itself
+  (re.compile(r'\b(?:gods? *)?damn\b',re.I),'dang',keep_case),
+  #Final catch-all
+  (re.compile(r'(?:gods? *)?damn',re.I),'dang',keep_case),
+  #########################################
+  # Bitch
+  #########################################
+  #Son of a bitch
+  (re.compile(r's[UuOo]n(s)?([ -])?[OoUu][FfVv]([ -])?(a)?([ -])?bitch(e)?',re.I),'jerk',keep_case),
+  #verb
+  (re.compile(r'bitchin[^\s]',re.U+re.I),'complaining',keep_case),
+  (re.compile(r'bitched',re.I),'complained',keep_case),
+  (re.compile(r'bitche?(?=s? abo)',re.I),'complain',keep_case),
+  (re.compile(r'(?<=(n([^\s]|o)t ))bitch',re.U+re.I),'complain',keep_case),
+  #A bitch
+  (re.compile(r's a bitch',re.I),'s tough',keep_case),
+  #Bitch by itself
+  (re.compile(r'\bbitch(e)?',re.I),'jerk',keep_case),
+  #########################################
+  # Shit
+  #########################################
+  #bullshit
+  (re.compile(r'\b(bull|horse|dog|jack)(.)?shit',re.I),'shit',keep_case),
+  #Holy shit
+  (re.compile(r'\bholy\W*shit',re.I),'incredible',keep_case),
+  #exclamantion
+  (re.compile(r'(?<=oh, )shit\b',re.I),'shoot',keep_case),
+  (re.compile(r'(?<=oh )shit\b',re.I),'shoot',keep_case),
+  (re.compile(r'(?<!\w )shit!',re.I),'shoot!',keep_case),
+  (re.compile(r'(?<=--)shit',re.I),'shoot',keep_case),
+  #no shit
+  (re.compile(r'(?<=no\W)shit\b',re.I),'kidding',keep_case),
+  #know shit
+  (re.compile(r'(?<=know\W)shit\b',re.I),'squat',keep_case),
+  #shit-load, head, can, hole, pot
+  (re.compile(r'shit(.)?load',re.I),'load',keep_case),
+  (re.compile(r'shit(.)?can',re.I),'trash',keep_case),
+  (re.compile(r'shit(.)?pot',re.I),'toilet',keep_case),
+  (re.compile(r'shit(.)?head',re.I),'idiot',keep_case),
+  (re.compile(r'shit(.)?hole',re.I),'pile of trash',keep_case),
+  #verb shittin'
+  (re.compile(r'shittin(?=[^\s])?',re.U+re.I),'kiddin',keep_case),
+  #shitter
+  (re.compile(r'shitter',re.I),'toilet',keep_case),
+  #shitty
+  (re.compile(r'shitty',re.I),'nasty',keep_case),
+  #shit-filled
+  (re.compile(r'\Wshit(.)?fill(ed)?',re.I),'',keep_case),
+  #shit
+  (re.compile(r'(?<=ive a )shit',re.I),'hoot',keep_case),
+  (re.compile(r'(?<=got )shit',re.I),'nothing',keep_case),
+  (re.compile(r'(?<=\w )shit',re.I),'trash',keep_case),
+  (re.compile(r'[S]hit(?=[,\.!?])',re.I),'incredible',keep_case),
+  (re.compile(r'\bshit\b',re.I),'rubbish',keep_case),
+  #########################################
+  # f-bomb
+  #########################################
+  (re.compile(r'(m[OoUu]th[AaEe]r?)?fuck',re.I),'zxsa',keep_case), #clean up script...
+  (re.compile(r'(m[OoUu]th[AaEe]r?)?fook',re.I),'zxsa',keep_case), #clean up script...
+  #f yourself
+  (re.compile(r'zxsa[\W]?yourself',re.I),"kill yourself",first_case),
+  #cluster f
+  (re.compile(r'cluster[\W]?zxsa',re.I),"massive failure",first_case),
+  #f your
+  (re.compile(r'zxsa[\W]?your',re.I),"bother your",first_case),
+  #f you
+  (re.compile(r'(?<!the[\W])zxsa[\W]?you',re.I),"forget you",first_case),
+  #you f up/with
+  (re.compile(r'(?<=you[\W])zxsa(?=[\W][UuWw])',re.I),"mess",first_case),
+  #f's
+  (re.compile(r'zxsas(?=\W(around|with|on\b|up\b|over|under|through))',re.U+re.I),"messes",first_case),
+  #f'in
+  (re.compile(r'zxsa(?=(in[^\s]?|s)?\W(around|with|on\b|up\b|over|under|through))',re.U+re.I),"mess",first_case),
+  ###f'ing A
+  (re.compile(r'zxsain[^\s]? a\b',re.U+re.I),"unbelievable",first_case),
+  (re.compile(r' (zxsain[^\s]?(?: well)?)(\W*.)',re.U+re.I),"",drop_first_match),
+  (re.compile(r'(zxsain[^\s]? (?:well)?)(\W*.)',re.U+re.I),"",drop_first_match),
+  (re.compile(r'zxsain[^\s]?',re.U+re.I),"frigging",keep_case),
+  #f'er
+  (re.compile(r'zxsaer',re.I),"idiot",keep_case),
+  #f'it
+  (re.compile(r'zxsa\W?it',re.I),"phoo",keep_case),
+  #f your/his/her/etc
+  (re.compile(r'zxsa(?=(ed)?\W(your|our|her|his|us|this|that|the\b|their|those|these|them|[^\s]em|for|a\b))',re.U+re.I),"harass",keep_case),
+  #f'ed
+  (re.compile(r'zxsaed',re.I),"messed",keep_case),
+  #f the
+  (re.compile(r'zxsa(?=[\W]the)',re.I),"forget",keep_case),
+  #the f
+  (re.compile(r'(?<=the[\W])zxsa\b',re.I),"heck",keep_case),
+  #verb
+  (re.compile(r'zxsa(?=\W(around|with|on\b|up\b|over|under|through))',re.I),"mess",first_case),
+  (re.compile(r'(?<=to\W)zxsa',re.I),"mess",first_case),
+  #f, f ups
+  (re.compile(r'zxsa(\W?up)?',re.I),"idiot",keep_case),
+  #########################################
+  # dick
+  #########################################
+  #dick around
+  (re.compile(r'dick(?=(in[^\s])?\W(around|with|on\b|up\b|over|under|through))',re.U+re.I),"mess",first_case),
+  #dickin['/g]
+  (re.compile(r'dick(?=(in[^\s][^o]))',re.U+re.I),"mess",keep_case),
+  #dickweed, dickhead
+  (re.compile(r'dick[WwHh]e[AaEe]d',re.I),"jerk",keep_case),
+  #know dick
+  (re.compile(r'(?<=[Kk]now )dick'),"squat",keep_case),
+  #dick on its own (toe is just sort of random...), not bird dickcissel
+  (re.compile(r'\bdick\b(?!-ciss)'),"toe",keep_case),
+  #########################################
+  # bastard
+  #########################################
+  (re.compile(r'\bbastard',re.I),"mongrel",keep_case),
+  #########################################
+  # hell
+  #########################################
+  #hellhound
+  (re.compile(r'\bhell\W?hound',re.I),'demonhound',keep_case),
+  #hell-word (not helldiver bird)
+  (re.compile(r'\bhell(?=-[^oO])(?!-diver)',re.I),'demon',keep_case),
+  #hell's bells
+  (re.compile(r'\bhell.{0,4}s?\W?bells?',re.I),'by golly',keep_case),
+  #hell with
+  (re.compile(r'(to|the)\Whell\Wwith',re.I),'forget',keep_case),
+  (re.compile(r'\bhell(?=\Wwith)',re.I),'heck',keep_case),
+  #beats the hell out of
+  (re.compile(r'beats\Wthe\Whell\Wout\Wof',re.I),'beats',keep_case),
+  #to hell
+  (re.compile(r'(?<=\bto\W)hell\b',re.I),'perdition',keep_case),
+  #some hell
+  (re.compile(r'(?<=some\W)hell\b',re.I),'trouble',keep_case),
+  #give/gave hell
+  (re.compile(r'(g[IiAa]ve\W.{0,7})hell\b(?!\Wof)',re.I),r'\1trouble',False),
+  #raise/raising hell
+  (re.compile(r'(rais[IiEe].{0,10})hell\b',re.I),r'\1trouble',False),
+  #chance in hell
+  (re.compile(r'(?<=chance)( in) hell\b(\W*.)',re.I),'*removed*',drop_first_match),
+  #burn in hell
+  (re.compile(r'(?<=burn)( in) hell\b(\W*.)',re.I),'*removed*',drop_first_match),
+  #living hell
+  (re.compile(r'(?<=living\W)hell\b',re.I),'prison',keep_case),
+  #for/etc the hell
+  (re.compile(r'(?<=(..for)\Wthe\W)hell\b',re.I),'heck',keep_case),
+  #what the hell[.?!]
+  (re.compile(r'what\Wthe\Whell(?=[\.?!\,])',re.I),'what the heck',keep_case),
+  #(in) the hell
+  (re.compile(r'(?: in)? (the)\Whell(?=[ \.?!\,])(?! in)(?! your)(?! out)(?! I\b)(?! of\b)(\W*.)',re.I),'*removed*',drop_first_match),
+  (re.compile(r'(?:in\W)?(the)\W+hell (?!in)(?!your)(?!out)(?!I\b)(?!of\b)(\W*.)',re.I),'*removed*',drop_first_match),
+  #(re.compile(r'(?:\Win)?\W(the)\Whell\b(?=[ \.?!\,])(?! in)(\W*.)',re.I),'*removed*',drop_first_match),
+  #what/how/whatever/etc the hell
+  (re.compile(r'(?<=(..how|..for|where|.what|tever|..who)\Wthe\W)hell\b',re.I),'heck',keep_case),
+  #sure/busy/etc. as hell
+  (re.compile(r'(?<!known)( as) hell\b(\W*.)',re.I),'',drop_first_match),
+  #way in hell
+  (re.compile(r'(?<=way) (in) hell\b(\W*.)',re.I),'',drop_first_match),
+  #what in hell
+  (re.compile(r'(?<=what) (in) hell\b(\W*.)',re.I),'',drop_first_match),
+  #but hell
+  (re.compile(r'(?<=but )hell\b',re.I),'heck',keep_case),
+  #Aw, hell
+  (re.compile(r'(?<=Aw, )hell\b',re.I),'heck',keep_case),
+  #catch hell
+  (re.compile(r'catch hell\b',re.I),'get in trouble',keep_case),
+  (re.compile(r'caught hell\b',re.I),'got in trouble',keep_case),
+  #as hell
+  (re.compile(r'sure as hell[ \,]',re.I),'for sure',keep_case),
+  (re.compile(r'ed as hell\b',re.I),'ed as could be',keep_case),
+  (re.compile(r'\bas hell[ \,]',re.I),'as could be',keep_case),
+  #all hell
+  (re.compile(r'\ball hell\b',re.I),'all perdition',keep_case),
+  #hell was
+  (re.compile(r'\bhell(?= was)',re.I),'heck',keep_case),
+  #hell to pay
+  (re.compile(r'\bhell(?= to pay)',re.I),'heck',keep_case),
+  #bloody hell
+  (re.compile(r'(?<=bloody.)hell\b',re.I),'heck',keep_case),
+  #dang hell
+  (re.compile(r'(?<=dang.)hell\b',re.I),'heck',keep_case),
+  #like hell
+  (re.compile(r'(?<=(..look|looked|..hurt) )like hell\b',re.I),'really bad',keep_case),
+  (re.compile(r'(?<=felt )like hell\b',re.I),'like garbage',keep_case),
+  (re.compile(r'L[Ii][Kk][Ee]\W[Hh][Ee][Ll][Ll]'),'not a chance',keep_case),
+  (re.compile(r'l[Ii][Kk][Ee]\W[Hh][Ee][Ll][Ll]'),'like mad',keep_case),
+  #The hell I
+  (re.compile(r'the\Whell\WI\b',re.I),'the heck I',keep_case),
+  #hell of/out/off ...
+  (re.compile(r'\bhell(?=\W(of\W|out|off\b|do\W|are\b))',re.I),'heck',keep_case),
+  #hellish
+  (re.compile(r'\bhellish',re.I),'unpleasant',keep_case),
+  #this/real hell (not followed by ?)
+  (re.compile(r'(?<=(this|real)\W)hell(\W?hole|\W?pit)?(?!\?)',re.I),'pit',keep_case),
+  #hell's
+  (re.compile(r'\thell[^\s]s',re.U+re.I),'perditions\'s',keep_case),
+  #interjection hell (preceeded by . or " or --, etc, followed by ,
+  (re.compile(r'(?<=([\.?!,]\W\W|..\"|”|“|.\W\W))hell(?=[,!])',re.U+re.I),'heck',keep_case),
+]
+#+ ass_list + lord_list
+
+DEBUG = True
+def language_check(text):
+  ret_val = re_list + lord_list
+  # Determine if this book is likely to take Lord's name in vain
+  if re.search("(for Christ's sake!|Holy Christ!|Holy Jesus!|for God's sake!|God almighty!|goddamn|fuck)",text,re.I):
+    if DEBUG:
+      print "Looks like book uses Lord's name in vain"
+    ret_val += vain_lord_list
+  else:
+    if DEBUG:
+      print "Looks like book does not use Lord's name in vain"
+  #Ass has two very different contexts. Guess which to use.
+  if re.search("(dumbass|asshole|smart ass|kick ass|ass kick|ass handed|badass|cover.{0,5}ass)",text):
+    ret_val += dirty_a_list
+    if DEBUG:
+      print "Looks like book does not need the donkey treatment"
+  else:
+    ret_val += clean_a_list
+    if DEBUG:
+      print "Looks like book calls donkeys asses"
+  #open('/tmp/dump.txt','w').write(text)
+  return ret_val
+    
+'''
+if DEBUG:
+  print text
+  print "-"*40
+  print "-"*40
+
+output = ""
+for line in text.split("\n"):
+  for search,sub,pcase in re_list:
+    if pcase: # Preserve case
+      line = search.sub(partial(pcase,sub),line)
+    else: # Don't preserve case
+      line = search.sub(sub,line)
+  output += line + "\n"
+
+if DEBUG:
+  print output
+'''
+#open('clensed.txt','w').write(output)
diff --git a/plugin-import-name-language_clean_plugin.txt b/plugin-import-name-language_clean_plugin.txt
new file mode 100644
index 0000000..e69de29