diff --git a/bwwtolily.py b/bwwtolily.py
index f31287f..adae9f2 100755
--- a/bwwtolily.py
+++ b/bwwtolily.py
@@ -7,400 +7,403 @@ GPL v3
 from optparse import OptionParser
 import sys,os,re,subprocess
 
-version = "0.4.0"
+version = "0.4.1"
+
+#make a print function to handle various version of python
+def do_print(string):
+	try:
+		eval("print "+string)
+	except:
+		print(string)
 
 #define the class that will convert a bww file to a lilypond file
 class bwwtolily :
+	def __init__(self,addmidi=False):
+			self.tune_elements = []
+			self.most_recent_note = 0
+			self.in_note_group=False
+			self.slur_tie_pending = False
+			self.last_group_close=0
+			'''compile a few regex queries'''
+			#make a regex to determine if something is a lilypond note
+			self.regex_lilynote= re.compile("[abcdefgAG][0-9]*")
+			#try to determine the time signature
+			self.sig_regex = re.compile("([0-9])_([0-9])")
+			#a regex to find notes
+			self.regex_note_info=re.compile("(?P<note>[A-Z]+)(?P<dir>[a-z]*)_(?P<time>[0-9]{1,2})")
+			#a regex to find grace notes
+			self.regex_grace_note = re.compile("([h|l]*[abcdefgt])g")
+			#a regex to parse doublings
+			self.regex_doubling = re.compile("^db([h|l]*[g|a|b|c|d|e|f]{1})")
+			#a regex to parse half_doublings
+			self.regex_half_doubling = re.compile("^hdb([h|l]*[g|a|b|c|d|e|f]{1})")
+			#a regex for finding strikes
+			self.regex_strike = re.compile("str([h|l]*[abcdefg])")
+			#a regex to find dots
+			self.regex_dot = re.compile("'[h|l]*[abcdefg]")
+			#a regex to find sub repeats
+			self.regex_sub_repeat = re.compile("'([0-9]+)")
+			#a regex to find note slurs, not slur embellishments
+			self.regex_slur = re.compile("\^(?P<note_count>[0-9])(?P<end_note>[a-z]*)")
+			#we need a list to ignore
+			self.ignore_elements = ("sharpf","sharpc","space","&")
+			#create a dictionary of common bww elements and their lily counterparts
+			self.transpose_dict = {
+			"!":"\\bar \"|\"\n",
+			"!I":"\\bar \".|\" \\break \n",
+			#"''!I":"\\set Score.repeatCommands = #'( end-repeat ) \\break \n",
+			"''!I":"\\bar \":|\" \\break\n",
+			#"''!I":"} \\break \n",
+			"I!''":"\\bar \"|:\"",
+			"I!":"\\bar \"|.\"",
+			#"I!''":"\\set Score.repeatCommands = #'( start-repeat )\n",
 
-    def __init__(self,addmidi=False):
-        self.tune_elements = []
-        self.most_recent_note = 0
-        self.in_note_group=False
-        self.slur_tie_pending = False
-        self.last_group_close=0
-        '''compile a few regex queries'''
-        #make a regex to determine if something is a lilypond note
-        self.regex_lilynote= re.compile("[abcdefgAG][0-9]*")
-        #try to determine the time signature
-        self.sig_regex = re.compile("([0-9])_([0-9])")
-        #a regex to find notes
-        self.regex_note_info=re.compile("(?P<note>[A-Z]+)(?P<dir>[a-z]*)_(?P<time>[0-9]{1,2})")
-        #a regex to find grace notes
-        self.regex_grace_note = re.compile("([h|l]*[abcdefgt])g")
-        #a regex to parse doublings
-        self.regex_doubling = re.compile("^db([h|l]*[g|a|b|c|d|e|f]{1})")
-        #a regex to parse half_doublings
-        self.regex_half_doubling = re.compile("^hdb([h|l]*[g|a|b|c|d|e|f]{1})")
-        #a regex for finding strikes
-        self.regex_strike = re.compile("str([h|l]*[abcdefg])")
-        #a regex to find dots
-        self.regex_dot = re.compile("'[h|l]*[abcdefg]")
-        #a regex to find sub repeats
-        self.regex_sub_repeat = re.compile("'([0-9]+)")
-        #a regex to find note slurs, not slur embellishments
-        self.regex_slur = re.compile("\^(?P<note_count>[0-9])(?P<end_note>[a-z]*)")
-        #we need a list to ignore
-        self.ignore_elements = ("sharpf","sharpc","space","&")
-        #create a dictionary of common bww elements and their lily counterparts
-        self.transpose_dict = {
-        "!":"\\bar \"|\"\n",
-        "!I":"\\bar \".|\" \\break \n",
-        #"''!I":"\\set Score.repeatCommands = #'( end-repeat ) \\break \n",
-        "''!I":"\\bar \":|\" \\break\n",
-        #"''!I":"} \\break \n",
-        "I!''":"\\bar \"|:\"",
-        "I!":"\\bar \"|.\"",
-        #"I!''":"\\set Score.repeatCommands = #'( start-repeat )\n",
+			#"I!''":"\n\\repeat volta 2 {\n",
+			"_'":"\\set Score.repeatCommands = #'((volta #f)) \\bar \"|\"\n",
+			"!t":"\\bar \"|\" \\break\n\n",
+			"thrd":"\\thrwd",
+			"gbr":"\\gbirl",
+			"brl":"\\wbirl",
+			"abr":"\\birl",
+			"lgstd":"\\dbld",
+			"gste":"\\slure",
+			"grp":"\\grip",
+			"tar":"\\taor",
+			"gstd":"\\slurd",
+			"tdbf":"\\tdblf"
+			}
+			#are we adding midi?
+			if addmidi:
+				self.lily_midi="\midi{}"
+			else:
+				self.lily_midi=''
 
-        #"I!''":"\n\\repeat volta 2 {\n",
-        "_'":"\\set Score.repeatCommands = #'((volta #f)) \\bar \"|\"\n",
-        "!t":"\\bar \"|\" \\break\n\n",
-        "thrd":"\\thrwd",
-        "gbr":"\\gbirl",
-        "brl":"\\wbirl",
-        "abr":"\\birl",
-        "lgstd":"\\dbld",
-        "gste":"\\slure",
-        "grp":"\\grip",
-        "tar":"\\taor",
-        "gstd":"\\slurd",
-        "tdbf":"\\tdblf"
-        }
-        #are we adding midi?
-        if addmidi:
-          self.lily_midi="\midi{}"
-        else:
-          self.lily_midi=''
+	def set_file(self,file_path):
+			#determine the absolute path to the file
+			abs_file = os.path.join(os.getcwd(),file_path)
+			file_name = os.path.basename(abs_file)
+			(self.name,ext) = file_name.split(".")
 
+			#does the file exist?
+			if os.path.isfile(abs_file):
+				self.original_file = abs_file
+				self.file_dir = os.path.dirname(abs_file)
+			else:
+				raise Exception(bww_file_path+" is not a file")
 
-    def set_file(self,file_path):
-        #determine the absolute path to the file
-        abs_file = os.path.join(os.getcwd(),file_path)
-        file_name = os.path.basename(abs_file)
-        (self.name,ext) = file_name.split(".")
+	def quit(self,string=""):
+			if string!="":
+				do_print( string)
+			sys.exit()
 
-        #does the file exist?
-        if os.path.isfile(abs_file):
-            self.original_file = abs_file
-            self.file_dir = os.path.dirname(abs_file)
-        else:
-            raise Exception(bww_file_path+" is not a file")
+	def parse(self):
+			'''reate a string that represents the converted
+			contents of the file'''
+			#open the file read only
+			file_handle = open(self.original_file,"r")
+			#read the contents of the file
+			file_text = file_handle.read()
+			#get the title,type,author of the file, these are in quotes
+			quote_regex = re.compile("\"(.*)\"")
+			tune_info = quote_regex.findall(file_text)
+			self.tune_title = tune_info[0]
+			self.tune_type = tune_info[1]
+			self.tune_author = tune_info[2]
+			#try to determine the time signature
+			result = self.sig_regex.search(file_text)
+			if result:
+				self.tune_time_sig = result.group(1)+"/"+result.group(2)
+			else:
+				self.tune_time_sig = "4/4"
 
-    def quit(self,string=""):
-        if string!="":
-            print string
-        sys.exit()
-    def parse(self):
-        '''reate a string that represents the converted
-        contents of the file'''
-        #open the file read only
-        file_handle = open(self.original_file,"r")
-        #read the contents of the file
-        file_text = file_handle.read()
-        #get the title,type,author of the file, these are in quotes
-        quote_regex = re.compile("\"(.*)\"")
-        tune_info = quote_regex.findall(file_text)
-        self.tune_title = tune_info[0]
-        self.tune_type = tune_info[1]
-        self.tune_author = tune_info[2]
-        #try to determine the time signature
-        result = self.sig_regex.search(file_text)
-        if result:
-            self.tune_time_sig = result.group(1)+"/"+result.group(2)
-        else:
-            self.tune_time_sig = "4/4"
-            
-        #get the tunes note info
-        '''greedy, multiline, from first ampersand to !'''
-        notes_regex = re.compile("&.*!I",re.S)
-        result = notes_regex.search(file_text)
-        try:
-            tune_notes = result.group()
-        except:
-            #no notes were found, what kind of file is this
-            self.quit("No notes were found.\nIs this a valid input file?")
-        #replace all whitespace characters with spaces
-        tune_notes = tune_notes.replace("\r"," ")
-        tune_notes = tune_notes.replace("\n"," ")
-        tune_notes = tune_notes.replace("\t"," ")
-        '''determine if there is a partial'''
-        '''
-        #get the first part of the notes from & to !
-        partial_regex = re.compile("&.*?[ |\r\n]!",re.S)
-        #partial_regex = re.compile("&.*?!",re.S)
-        result = partial_regex.findall(tune_notes)
-        search_string = result[0]
-        #find the time of the notes in the search string
-        partial_regex = re.compile("[A-Z]+[a-z]*_([0-9]{1,2})")
-        result = partial_regex.findall(search_string)
-        self.tune_partial_string = ""
-        if result:
-            partial_time = 0
-            #TODO: determine the proper way to determine the partial
-            for number in result:
-                partial_time += (1.0/int(number))
-            print "time: %s" % ( partial_time )
-            #how many quarter notes is this?
-            quarters = partial_time/.25
-            print "quarters: %d" % quarters
-            #self.tune_partial_string = "\\partial %d" % quarters
-            #self.tune_partial_string = "\\partial "+str(part)
-        '''
-        #split the string into it's constituents elements
-        elements = tune_notes.split()
-        for element in elements:
-            self.transpose(element)
-        #print self.tune_notes
+			#get the tunes note info
+			'''greedy, multiline, from first ampersand to !'''
+			notes_regex = re.compile("&.*!I",re.S)
+			result = notes_regex.search(file_text)
+			try:
+				tune_notes = result.group()
+			except:
+				#no notes were found, what kind of file is this
+				self.quit("No notes were found.\nIs this a valid input file?")
+			#replace all whitespace characters with spaces
+			tune_notes = tune_notes.replace("\r"," ")
+			tune_notes = tune_notes.replace("\n"," ")
+			tune_notes = tune_notes.replace("\t"," ")
+			'''determine if there is a partial'''
+			'''
+			#get the first part of the notes from & to !
+			partial_regex = re.compile("&.*?[ |\r\n]!",re.S)
+			#partial_regex = re.compile("&.*?!",re.S)
+			result = partial_regex.findall(tune_notes)
+			search_string = result[0]
+			#find the time of the notes in the search string
+			partial_regex = re.compile("[A-Z]+[a-z]*_([0-9]{1,2})")
+			result = partial_regex.findall(search_string)
+			self.tune_partial_string = ""
+			if result:
+				partial_time = 0
+				#TODO: determine the proper way to determine the partial
+				for number in result:
+					partial_time += (1.0/int(number))
+				print "time: %s" % ( partial_time )
+				#how many quarter notes is this?
+				quarters = partial_time/.25
+				print "quarters: %d" % quarters
+				#self.tune_partial_string = "\\partial %d" % quarters
+				#self.tune_partial_string = "\\partial "+str(part)
+			'''
+			#split the string into it's constituents elements
+			elements = tune_notes.split()
+			for element in elements:
+				self.transpose(element)
 
+	def lilynote(self,bwwname):
+			#convert a bww notename to a lilypond notename
+			#make the notename lowercase
+			notename = bwwname.lower()
 
-    def lilynote(self,bwwname):
-        #convert a bww notename to a lilypond notename
-        #make the notename lowercase
-        notename = bwwname.lower()
+			if notename =="lg":
+				lilynote = "G"
+			elif notename == "la":
+				lilynote ="a"
+			elif notename == "hg":
+				lilynote = "g"
+			elif notename == "ha" or notename =="t":
+				lilynote = "A"
+			else:
+				lilynote = notename
+			return lilynote
 
-        if notename =="lg":
-            lilynote = "G"
-        elif notename == "la":
-            lilynote ="a"
-        elif notename == "hg":
-            lilynote = "g"
-        elif notename == "ha" or notename =="t":
-            lilynote = "A"
-        else:
-            lilynote = notename
-        return lilynote
+	def transpose(self,element):
+			'''receive a bww element and return a lilypond equivelent'''
 
-    def transpose(self,element):
-        '''receive a bww element and return a lilypond equivelent'''
+			#is the element a note?
+			note_result = self.regex_note_info.search(element)
+			if note_result:
+				note = self.lilynote( note_result.group("note") )+note_result.group("time")
+				#is a tie slur pending?
+				if self.slur_tie_pending:
+					self.slur_tie_pending=False
+					note+="~"
+				self.tune_elements.append(note)
+				self.most_recent_note = len(self.tune_elements)-1
+				if note_result.group("dir") == "r" and not self.in_note_group:
+					self.in_note_group=True
+					self.tune_elements.append("[")
+				elif note_result.group("dir") == "l":
+					if self.in_note_group:
+							self.in_note_group=False
+							self.tune_elements.append("]")
+							self.last_group_close = len(self.tune_elements)-1
+					else:
+							#delete the last group close
+							del(self.tune_elements[self.last_group_close])
+							#decrement the most recent note
+							self.most_recent_note-=1
+							self.tune_elements.append("]")
+				return
+			#is the element a grace note?
+			grace_result=self.regex_grace_note.search(element)
+			if grace_result:
+				grace = "\\gr"+self.lilynote( grace_result.group(1) )
+				self.tune_elements.append(grace)
+				return
+			#is the element a doubling?
+			doubling_result=self.regex_doubling.search(element)
+			if doubling_result:
+				doubling = "\\dbl"+self.lilynote( doubling_result.group(1) )
+				self.tune_elements.append(doubling)
+				return
+			#is the element a half doubling?
+			hdoubling_result=self.regex_half_doubling.search(element)
+			if hdoubling_result:
+				half_doubling = "\\hdbl"+self.lilynote( hdoubling_result.group(1) )
+				self.tune_elements.append(half_doubling)
+				return
+			#is the element a strike?
+			strike_result=self.regex_strike.search(element)
+			if strike_result:
+				strike = "\\slur"+self.lilynote( strike_result.group(1) )
+				#if the strike is on low g \\slurG
+				if strike =="\\slurG":
+					#let the strike be a low g grace note
+					strike = "\\grG"
+				#if the strike is on high G
+				elif strike =="\\slurg":
+					#let the strike be a grace note on the high g
+					strike = "\\grg"
+				#if hte strike is on low a
+				elif strike == "\\slura":
+					#let the strike be a grace not on low a
+					strike = "\\gra"
+				self.tune_elements.append(strike)
+				return
+			#is the element a dot?
+			dot_result=self.regex_dot.search(element)
+			if dot_result:
+				#add a dot to the last note
+				note = self.tune_elements[self.most_recent_note]
+				if note[-1]=="~":
+					self.tune_elements[self.most_recent_note].replace("~",".~")
+				else:
+					self.tune_elements[self.most_recent_note]+="."
+				return
 
-        #is the element a note?
-        note_result = self.regex_note_info.search(element)
-        if note_result:
-            note = self.lilynote( note_result.group("note") )+note_result.group("time")
-            #is a tie slur pending?
-            if self.slur_tie_pending:
-              self.slur_tie_pending=False
-              note+="~"
-            self.tune_elements.append(note)
-            self.most_recent_note = len(self.tune_elements)-1
-            if note_result.group("dir") == "r" and not self.in_note_group:
-                self.in_note_group=True
-                self.tune_elements.append("[")
-            elif note_result.group("dir") == "l":
-                if self.in_note_group:
-                    self.in_note_group=False
-                    self.tune_elements.append("]")
-                    self.last_group_close = len(self.tune_elements)-1
-                else:
-                    #delete the last group close
-                    del(self.tune_elements[self.last_group_close])
-                    #decrement the most recent note
-                    self.most_recent_note-=1
-                    self.tune_elements.append("]")
-            return
-        #is the element a grace note?
-        grace_result=self.regex_grace_note.search(element)
-        if grace_result:
-            grace = "\\gr"+self.lilynote( grace_result.group(1) )
-            self.tune_elements.append(grace)
-            return
-        #is the element a doubling?
-        doubling_result=self.regex_doubling.search(element)
-        if doubling_result:
-            doubling = "\\dbl"+self.lilynote( doubling_result.group(1) )
-            self.tune_elements.append(doubling)
-            return
-        #is the element a half doubling?
-        hdoubling_result=self.regex_half_doubling.search(element)
-        if hdoubling_result:
-            half_doubling = "\\hdbl"+self.lilynote( hdoubling_result.group(1) )
-            self.tune_elements.append(half_doubling)
-            return
-        #is the element a strike?
-        strike_result=self.regex_strike.search(element)
-        if strike_result:
-            strike = "\\slur"+self.lilynote( strike_result.group(1) )
-            #if the strike is on low g \\slurG
-            if strike =="\\slurG":
-                #let the strike be a low g grace note
-                strike = "\\grG"
-            #if the strike is on high G
-            elif strike =="\\slurg":
-                #let the strike be a grace note on the high g
-                strike = "\\grg"
-            #if hte strike is on low a
-            elif strike == "\\slura":
-                #let the strike be a grace not on low a
-                strike = "\\gra"
-            self.tune_elements.append(strike)
-            return
-        #is the element a dot?
-        dot_result=self.regex_dot.search(element)
-        if dot_result:
-            #add a dot to the last note
-            note = self.tune_elements[self.most_recent_note]
-            if note[-1]=="~":
-              self.tune_elements[self.most_recent_note].replace("~",".~")
-            else:
-              self.tune_elements[self.most_recent_note]+="."
-            return
-            
-        #is the element a slur?
-        slur_result = self.regex_slur.search(element)
-        if slur_result:
-            #get the matching elements
-            note_count = slur_result.group("note_count")
-            end_note = slur_result.group("end_note")
-            #get the length of the slur as an integer
-            slur_len = int(note_count)
-            '''find the position of the note that is slur_len from the end'''
-            #get the tune_elements lenght
-            elem_index = len(self.tune_elements)-1
-            note_count = 0
-            while note_count<2:
-                element = self.tune_elements[elem_index]
-                #is this element a note?
-                is_note = self.regex_lilynote.search(element)
-                if is_note:
-                    #increment the note count
-                    note_count+=1
-                #decrease the element index
-                elem_index-=1
-            
-            #add the slur start just after the start note
-            self.tune_elements.insert(elem_index+1,"(") 
-            #add the slur end
-            self.tune_elements.append(")")
-            return
-        #is this a bww tie slur?
-        if element == "^ts":
-          self.slur_tie_pending = True
-          return
-          
-        #is the element the start of a sub_repeat?
-        sub_repeat_result = self.regex_sub_repeat.search(element)
-        if sub_repeat_result:
-            sub_repeat = "\\set Score.repeatCommands = #'((volta \"%s\")) " % ( sub_repeat_result.group(1) )
-            self.tune_elements.append(sub_repeat)
-            return
-        else:
-            #is the element in the ignore list?
-            if element in self.ignore_elements:
-                return
-            '''
-            if the element is an start double,
-            check if the previous element was a end double
-            '''
-            if len(self.tune_elements):
-                last_element = self.tune_elements[-1]
-                if element=="I!''" and last_element.find(":|"):
-                    #replace the last element with a double double
-                    self.tune_elements[-1] = "\\bar \":|:\" \\break\n\n"
-                    return
-            #is this a time sig?
-            result = self.sig_regex.search(element)
-            if result:
-                return
-            try:
+			#is the element a slur?
+			slur_result = self.regex_slur.search(element)
+			if slur_result:
+				#get the matching elements
+				note_count = slur_result.group("note_count")
+				end_note = slur_result.group("end_note")
+				#get the length of the slur as an integer
+				slur_len = int(note_count)
+				'''find the position of the note that is slur_len from the end'''
+				#get the tune_elements lenght
+				elem_index = len(self.tune_elements)-1
+				note_count = 0
+				while note_count<2:
+					element = self.tune_elements[elem_index]
+					#is this element a note?
+					is_note = self.regex_lilynote.search(element)
+					if is_note:
+							#increment the note count
+							note_count+=1
+					#decrease the element index
+					elem_index-=1
 
-                dict_result = self.transpose_dict[element]
-                if dict_result:
-                    self.tune_elements.append(dict_result)
-                    return
-            except:
-                print "unparsed: "+element
-        return
+				#add the slur start just after the start note
+				self.tune_elements.insert(elem_index+1,"(")
+				#add the slur end
+				self.tune_elements.append(")")
+				return
+			#is this a bww tie slur?
+			if element == "^ts":
+				self.slur_tie_pending = True
+				return
 
+			#is the element the start of a sub_repeat?
+			sub_repeat_result = self.regex_sub_repeat.search(element)
+			if sub_repeat_result:
+				sub_repeat = "\\set Score.repeatCommands = #'((volta \"%s\")) " % ( sub_repeat_result.group(1) )
+				self.tune_elements.append(sub_repeat)
+				return
+			else:
+				#is the element in the ignore list?
+				if element in self.ignore_elements:
+					return
+				'''
+				if the element is an start double,
+				check if the previous element was a end double
+				'''
+				if len(self.tune_elements):
+					last_element = self.tune_elements[-1]
+					if element=="I!''" and last_element.find(":|"):
+							#replace the last element with a double double
+							self.tune_elements[-1] = "\\bar \":|:\" \\break\n\n"
+							return
+				#is this a time sig?
+				result = self.sig_regex.search(element)
+				if result:
+					return
+				try:
 
-    #handle writing the output
-    def create_output_file(self):
-        #determine the output file
-        output_file = os.path.join(self.file_dir,self.name+".ly")
-        #open the file for writing
-        file_handle = open(output_file,"w")
-        #write the data to the file
-        text = self.get_lilypond_text()
-        file_handle.write(text)
-        #close the handle
-        file_handle.close()
-        #return the string of the path to the file
-        return output_file
+					dict_result = self.transpose_dict[element]
+					if dict_result:
+							self.tune_elements.append(dict_result)
+							return
+				except:
+					do_print( "unparsed: "+element)
+			return
 
-    def get_lilypond_text(self):
-        tune_text = " ".join(self.tune_elements)
-        lptext ='''\\include "bagpipe.ly"
+	#handle writing the output
+	def create_output_file(self):
+			#determine the output file
+			output_file = os.path.join(self.file_dir,self.name+".ly")
+			#open the file for writing
+			file_handle = open(output_file,"w")
+			#write the data to the file
+			text = self.get_lilypond_text()
+			file_handle.write(text)
+			#close the handle
+			file_handle.close()
+			#return the string of the path to the file
+			return output_file
+
+	def get_lilypond_text(self):
+			tune_text = " ".join(self.tune_elements)
+			lptext ='''\\include "bagpipe.ly"
 melody = {
-       \\set Staff.midiInstrument = #"bagpipe"    
-       \\hideKeySignature
-       \\cadenzaOn
-       \\once \\override Score.BreakAlignment #'break-align-orders =
-        #(make-vector 3 '(instrument-name
-                          left-edge
-                          ambitus
-                          span-bar
-                          breathing-sign
-                          clef
-                          key-signature
-                          time-signature
-                          staff-bar
-                          custos
-                          span-bar))
-       \\time %s
-       %s
-        }
+		\\set Staff.midiInstrument = #"bagpipe"
+		\\hideKeySignature
+		\\cadenzaOn
+		\\once \\override Score.BreakAlignment #'break-align-orders =
+			#(make-vector 3 '(instrument-name
+									left-edge
+									ambitus
+									span-bar
+									breathing-sign
+									clef
+									key-signature
+									time-signature
+									staff-bar
+									custos
+									span-bar))
+		\\time %s
+		%s
+			}
 
 \\score {
-  \\melody
-  \\layout {
-    indent = 0.0\\cm
-    \\context { \\Score \\remove "Bar_number_engraver" }
-  }
-  \\header {
-    title = "%s"
-    meter = "%s"
-    arranger = "%s"
-  }
-  %s
+	\\melody
+	\\layout {
+	indent = 0.0\\cm
+	\\context { \\Score \\remove "Bar_number_engraver" }
+	}
+	\\header {
+	title = "%s"
+	meter = "%s"
+	arranger = "%s"
+	}
+	%s
 }
 
-''' % (self.tune_time_sig, 
-        tune_text,
-        self.tune_title,
-        self.tune_type,
-        self.tune_author,
-        self.lily_midi
-        )
-        return lptext
+''' % (self.tune_time_sig,
+			tune_text,
+			self.tune_title,
+			self.tune_type,
+			self.tune_author,
+			self.lily_midi
+			)
+			return lptext
 
 #use the bww2lily class
 if __name__ == "__main__" :
-    parser = OptionParser()
-    parser.add_option("-i", "--in", dest="input",
-          help="the FILE to convert", metavar="FILE")
-    parser.add_option("-l", "--lilypond",
-          action="store_true", dest="runlilypond", default=False,
-          help="run lilypond after converting the file")
-    parser.add_option("-m", "--midi",
-          action="store_true", dest="addmidi", default=False,
-          help="add midi output to the lilypond file")
-    parser.add_option("-v","--version",dest='version', default=False,
-          action="store_true",help="print version information and quit")
-    
-    #parse the args
-    (options, args) = parser.parse_args()
-    if options.version:
-        print "bwwtolily: ",version
-        sys.exit()
+	parser = OptionParser()
+	parser.add_option("-i", "--in", dest="input",
+			help="the FILE to convert", metavar="FILE")
+	parser.add_option("-l", "--lilypond",
+			action="store_true", dest="runlilypond",default=False,
+			help="run lilypond after converting the file")
+	parser.add_option("-m", "--midi",
+			action="store_true", dest="addmidi",default=False,
+			help="add midi output to the lilypond file")
+	parser.add_option("-v","--version",dest='version',default=False,
+			action="store_true",help="print version information and quit")
 
-    if options.input!=None:
-        b2l = bwwtolily(options.addmidi)
-        b2l.set_file(options.input)
-        b2l.parse()
-        new_file = b2l.create_output_file()
-        #are we running lilypond?
-        if options.runlilypond:
-            #try to run lilypond as a subprocess
-            subprocess.check_call("lilypond \""+new_file+"\"",shell=True)
-    else:
-      parser.print_help()  
+	#parse the args
+	(options, args) = parser.parse_args()
+	if options.version:
+			do_print( "bwwtolily: ",version)
+			sys.exit()
+
+	if options.input!=None:
+			b2l = bwwtolily(options.addmidi)
+			b2l.set_file(options.input)
+			b2l.parse()
+			new_file = b2l.create_output_file()
+			#are we running lilypond?
+			if options.runlilypond:
+				#try to run lilypond as a subprocess
+				subprocess.check_call("lilypond \""+new_file+"\"",shell=True)
+	else:
+		parser.print_help()
 sys.exit()