diff --git a/backup.py b/backup.py
index e8b3bca..a0aaa0d 100644
--- a/backup.py
+++ b/backup.py
@@ -1,11 +1,12 @@
 import json
 import re
 
+
 def parse_vtt(vtt_filename):
-    with open(vtt_filename, 'r', encoding='utf-8') as file:
+    with open(vtt_filename, "r", encoding="utf-8") as file:
         lines = file.readlines()
 
-    time_pattern = re.compile(r'(\d+\.\d{3}) --> (\d+\.\d{3})')
+    time_pattern = re.compile(r"(\d+\.\d{3}) --> (\d+\.\d{3})")
 
     subtitles = []
     current_subtitle = {}
@@ -13,43 +14,47 @@ def parse_vtt(vtt_filename):
     for line in lines[1:]:
         match = time_pattern.match(line)
         if match:
-            current_subtitle['start'] = float(match.group(1))
-            current_subtitle['end'] = float(match.group(2))
-            current_subtitle['content'] = ""
-        elif line.strip() == '':
+            current_subtitle["start"] = float(match.group(1))
+            current_subtitle["end"] = float(match.group(2))
+            current_subtitle["content"] = ""
+        elif line.strip() == "":
             if current_subtitle:
-                if current_subtitle['content'][-1] == "\n":
-                    current_subtitle['content'] = current_subtitle['content'][:-1]
+                if current_subtitle["content"][-1] == "\n":
+                    current_subtitle["content"] = current_subtitle["content"][:-1]
                 subtitles.append(current_subtitle)
                 current_subtitle = {}
         else:
-            current_subtitle['content'] += line.strip() + "\n"  # Space to separate lines
+            current_subtitle["content"] += (
+                line.strip() + "\n"
+            )  # Space to separate lines
 
     if current_subtitle:
-        if current_subtitle['content'][-1] == "\n":
-            current_subtitle['content'] = current_subtitle['content'][:-1]
+        if current_subtitle["content"][-1] == "\n":
+            current_subtitle["content"] = current_subtitle["content"][:-1]
         subtitles.append(current_subtitle)
 
     return subtitles
 
-def subtitles_to_backup(subtitles):
 
+def subtitles_to_backup(subtitles):
     backup_data = {
-        "subtitles": subtitles, 
+        "subtitles": subtitles,
         "script_lines": [],
         "line_index": len(subtitles),
-        "current_subtitle": {}, 
-        "play": 0
+        "current_subtitle": {},
+        "play": 0,
     }
     return backup_data
 
+
 def main(vtt_filename, output_filename):
     subtitles = parse_vtt(vtt_filename)
     backup_data = subtitles_to_backup(subtitles)
 
-    with open(output_filename, 'w', encoding='utf-8') as json_file:
+    with open(output_filename, "w", encoding="utf-8") as json_file:
         json.dump(backup_data, json_file, indent=2)
 
-vtt_filename = 'audio.vtt'
-output_filename = 'backup2.json'
+
+vtt_filename = "audio.vtt"
+output_filename = "backup2.json"
 main(vtt_filename, output_filename)
diff --git a/snusub.py b/snusub.py
index b9ab1e5..bf85045 100644
--- a/snusub.py
+++ b/snusub.py
@@ -6,410 +6,479 @@ from datetime import timedelta
 
 ###
 
+
 def from_vtt(vtt_string):
-  VTT_TIMECODE_PATTERN = r"((?:\d{2}:)?\d{2}:\d{2}\.\d{3}) --> ((?:\d{2}:)?\d{2}:\d{2}\.\d{3})"
-  VTT_LINE_NUMBER_PATTERN = r"^\d+$"
-  parts = re.split(r'\n\n+', vtt_string.strip())
-  if parts[0].startswith('WEBVTT'):
-    parts.pop(0)
+    VTT_TIMECODE_PATTERN = (
+        r"((?:\d{2}:)?\d{2}:\d{2}\.\d{3}) --> ((?:\d{2}:)?\d{2}:\d{2}\.\d{3})"
+    )
+    VTT_LINE_NUMBER_PATTERN = r"^\d+$"
+    parts = re.split(r"\n\n+", vtt_string.strip())
+    if parts[0].startswith("WEBVTT"):
+        parts.pop(0)
 
-  subtitles = []
-  for part in parts:
-    lines = part.split('\n')
-    match = re.match(VTT_TIMECODE_PATTERN, lines[0])
-    if not match:
-      if re.match(VTT_LINE_NUMBER_PATTERN, lines[0]):
-        lines.pop(0)
-      match = re.match(VTT_TIMECODE_PATTERN, lines[0])
-    if not match:
-      continue
+    subtitles = []
+    for part in parts:
+        lines = part.split("\n")
+        match = re.match(VTT_TIMECODE_PATTERN, lines[0])
+        if not match:
+            if re.match(VTT_LINE_NUMBER_PATTERN, lines[0]):
+                lines.pop(0)
+            match = re.match(VTT_TIMECODE_PATTERN, lines[0])
+        if not match:
+            continue
 
-    start, end = match.groups()
-    content = '\n'.join(lines[1:]) + "\n"
-    # if start == end:
-    #   continue
-      
-    subtitles.append({
-      'start': start,
-      'end': end,
-      'content': (content.replace("-\n", "\n").replace("</u>-\n", "</u>\n").replace("-", " ").replace("%", " ").replace("<u> "," <u>").replace(" </u>","</u> ").replace("<u> </u>","").replace("<u></u>","").replace(" \n", "\n"))[:-1]
-    })
+        start, end = match.groups()
+        content = "\n".join(lines[1:]) + "\n"
+        # if start == end:
+        #   continue
+
+        subtitles.append(
+            {
+                "start": start,
+                "end": end,
+                "content": (
+                    content.replace("-\n", "\n")
+                    .replace("</u>-\n", "</u>\n")
+                    .replace("-", " ")
+                    .replace("%", " ")
+                    .replace("<u> ", " <u>")
+                    .replace(" </u>", "</u> ")
+                    .replace("<u> </u>", "")
+                    .replace("<u></u>", "")
+                    .replace(" \n", "\n")
+                )[:-1],
+            }
+        )
+
+    return subtitles
 
-  return subtitles
 
 def to_vtt(subtitles):
     vtt_content = "WEBVTT\n\n\n"
     for idx, subtitle in enumerate(subtitles):
-        content = subtitle['content']
+        content = subtitle["content"]
         if not subtitle.get("split", False):
-          start = subtitle['start']
-          end = subtitle['end']
-          if not start or not end or start == end:
-            raise Exception(f"VTT timestamp parse error from #{idx}.")
-          vtt_content += f"{start} --> {end}\n{content}\n\n\n"
+            start = subtitle["start"]
+            end = subtitle["end"]
+            if not start or not end or start == end:
+                raise Exception(f"VTT timestamp parse error from #{idx}.")
+            vtt_content += f"{start} --> {end}\n{content}\n\n\n"
         else:
-          vtt_content += f"NOTE {content}\n\n\n"
+            vtt_content += f"NOTE {content}\n\n\n"
 
     return vtt_content.strip()
 
-def to_stacked_vtt(subtitles, continous = True):
-  vtt_content = "WEBVTT\n\n\n"
-  buffer = ""
-  for n, subtitle in enumerate(subtitles):
-    if subtitle.get("split", False):
-      buffer = ""
-      continue
 
-    if len(buffer) != 0:
-      if str(subtitle['content'].strip())[-1] == ".":
-        buffer += "\n"
-      else:
-        buffer += " "
+def to_stacked_vtt(subtitles, continous=True):
+    vtt_content = "WEBVTT\n\n\n"
+    buffer = ""
+    for n, subtitle in enumerate(subtitles):
+        if subtitle.get("split", False):
+            buffer = ""
+            continue
 
-    buffer += subtitle['content'].strip()
+        if len(buffer) != 0:
+            if str(subtitle["content"].strip())[-1] == ".":
+                buffer += "\n"
+            else:
+                buffer += " "
 
-    if n < len(subtitles) - 1:
-      end_time = subtitles[n+1]['start'] if continous and not subtitles[n+1].get("split", False) else subtitle['end']
-    else:
-      end_time = subtitle['end']
-    
-    if not subtitle['start'] or not end_time:
-      raise Exception(f"VTT timestamp parse error from #{idx}.")
-    if subtitle['start'] == end_time:
-      raise Exception(f"Error, subtitle timestamp overlaps.\n{subtitle['start']} --> {end_time} {subtitle['content'].strip()}")
-    vtt_content += f"{subtitle['start']} --> {end_time}\n"
-    vtt_content += buffer
-    vtt_content += "\n\n\n"
+        buffer += subtitle["content"].strip()
 
-    print(f"{subtitle['start']} --> {end_time}\n{buffer}\n\n")
+        if n < len(subtitles) - 1:
+            end_time = (
+                subtitles[n + 1]["start"]
+                if continous and not subtitles[n + 1].get("split", False)
+                else subtitle["end"]
+            )
+        else:
+            end_time = subtitle["end"]
+
+        if not subtitle["start"] or not end_time:
+            raise Exception(f"VTT timestamp parse error from #{idx}.")
+        if subtitle["start"] == end_time:
+            raise Exception(
+                f"Error, subtitle timestamp overlaps.\n{subtitle['start']} --> {end_time} {subtitle['content'].strip()}"
+            )
+        vtt_content += f"{subtitle['start']} --> {end_time}\n"
+        vtt_content += buffer
+        vtt_content += "\n\n\n"
+
+        print(f"{subtitle['start']} --> {end_time}\n{buffer}\n\n")
+
+    return vtt_content
 
-  return vtt_content
 
 ###
 
+
 def script_from_word_vtt(wordvtt):
-  subtitles = from_vtt(wordvtt)
-  print(f"Generating script file from VTT...")
-  sentences = []
-  ADD_NEXT_SENTENCE = 0
-  for n, subtitle in enumerate(subtitles):
-    sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
-    if ((sentences[-1] if sentences else None) != sentence) or ADD_NEXT_SENTENCE:
-      sentences.append(sentence)
-      ADD_NEXT_SENTENCE = 0
-    if subtitle["content"][-4:] == "</u>":
-      ADD_NEXT_SENTENCE = 1
-      if n + 2 < len(subtitles):
-        if subtitles[n+2]["content"].replace("<u>", "").replace("</u>", "") != sentence:
-          ADD_NEXT_SENTENCE = 0
-  return sentences
+    subtitles = from_vtt(wordvtt)
+    print(f"Generating script file from VTT...")
+    sentences = []
+    ADD_NEXT_SENTENCE = 0
+    for n, subtitle in enumerate(subtitles):
+        sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
+        if ((sentences[-1] if sentences else None) != sentence) or ADD_NEXT_SENTENCE:
+            sentences.append(sentence)
+            ADD_NEXT_SENTENCE = 0
+        if subtitle["content"][-4:] == "</u>":
+            ADD_NEXT_SENTENCE = 1
+            if n + 2 < len(subtitles):
+                if (
+                    subtitles[n + 2]["content"].replace("<u>", "").replace("</u>", "")
+                    != sentence
+                ):
+                    ADD_NEXT_SENTENCE = 0
+    return sentences
+
 
 def create_word_scenes(raw_vtt, raw_script):
-  subtitles = from_vtt(raw_vtt)
-  scripts   = [i for i in raw_script.split("\n") if i]
-  print(f"Found {len(subtitles)} subtitles, {len(scripts)} scenes.\nTimestamping each words...")
+    subtitles = from_vtt(raw_vtt)
+    scripts = [i for i in raw_script.split("\n") if i]
+    print(
+        f"Found {len(subtitles)} subtitles, {len(scripts)} scenes.\nTimestamping each words..."
+    )
 
-  scenes = []
-  for n, script in enumerate(scripts):
-    if len(script.split(" ")) == 1:
-      continue
-    scenes.append({"scene": script, "timestamp": []})
+    scenes = []
+    for n, script in enumerate(scripts):
+        if len(script.split(" ")) == 1:
+            continue
+        scenes.append({"scene": script, "timestamp": []})
 
-  scenes_cur = 0
-  for n, subtitle in enumerate(subtitles):
-    sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
-    if len(sentence.split(" ")) == 1:
-      continue
+    scenes_cur = 0
+    for n, subtitle in enumerate(subtitles):
+        sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
+        if len(sentence.split(" ")) == 1:
+            continue
 
-    if sentence != scenes[scenes_cur].get("scene"):
-      if sentence == scenes[scenes_cur+1].get("scene"):
-        scenes_cur += 1
-      else:
-        raise Exception(f"Error, Failed to match sentence with scene.\n\"{scenes[scenes_cur].get("scene")}\" or \"[{scenes_cur+1}] {scenes[scenes_cur+1].get("scene")}\" != \"{sentence}\"")
+        if sentence != scenes[scenes_cur].get("scene"):
+            if sentence == scenes[scenes_cur + 1].get("scene"):
+                scenes_cur += 1
+            else:
+                raise Exception(
+                    f"Error, Failed to match sentence with scene.\n\"{scenes[scenes_cur].get("scene")}\" or \"[{scenes_cur+1}] {scenes[scenes_cur+1].get("scene")}\" != \"{sentence}\""
+                )
 
-    current_scene = scenes[scenes_cur]
-    if current_scene["timestamp"]:
-      word_idx = current_scene["timestamp"][-1]["index"] + 1
-    else:
-      word_idx = 0
+        current_scene = scenes[scenes_cur]
+        if current_scene["timestamp"]:
+            word_idx = current_scene["timestamp"][-1]["index"] + 1
+        else:
+            word_idx = 0
 
-    if ("<u>" not in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
-      # Ignore trailing dummy subtitle after last word indexed.
-      pass
+        if ("<u>" not in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
+            # Ignore trailing dummy subtitle after last word indexed.
+            pass
 
-    if ("<u>" in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
-      # If there is trailing non-dummy timestamped subtitle, Reset word_idx and step to next scene. (Repeating sentence doesnt increment cur.)
-      print(f"Error, Index wrong. {scenes_cur}, word: {word_idx}, total words: {len(sentence.split(" "))}\n{subtitle}")
-      word_idx = 0
-      scenes_cur += 1
-      current_scene = scenes[scenes_cur]
-      if current_scene["timestamp"]:
-        word_idx = current_scene["timestamp"][-1]["index"] + 1
-      else:
-        word_idx = 0
-      print(f"Changed to {word_idx}, {scenes_cur}")
+        if ("<u>" in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
+            # If there is trailing non-dummy timestamped subtitle, Reset word_idx and step to next scene. (Repeating sentence doesnt increment cur.)
+            print(
+                f"Error, Index wrong. {scenes_cur}, word: {word_idx}, total words: {len(sentence.split(" "))}\n{subtitle}"
+            )
+            word_idx = 0
+            scenes_cur += 1
+            current_scene = scenes[scenes_cur]
+            if current_scene["timestamp"]:
+                word_idx = current_scene["timestamp"][-1]["index"] + 1
+            else:
+                word_idx = 0
+            print(f"Changed to {word_idx}, {scenes_cur}")
 
-    # Start matching words.
-    if "<u>" in subtitle["content"]:
-      word = subtitle["content"].split("<u>")[1].split("</u>")[0]
+        # Start matching words.
+        if "<u>" in subtitle["content"]:
+            word = subtitle["content"].split("<u>")[1].split("</u>")[0]
 
-      if word not in sentence.split(" "):
-        raise Exception(f"Error, Mismatch\n=> \"{word}\" not in \"{sentence}\"")
-        return
+            if word not in sentence.split(" "):
+                raise Exception(f'Error, Mismatch\n=> "{word}" not in "{sentence}"')
+                return
 
-      try:
-        assert sentence.split(" ")[word_idx] == word
-      except:
-        raise Exception(f"Error, Mismatch\n=> \"{word}\" != [{word_idx}] of \"{sentence}\"")
+            try:
+                assert sentence.split(" ")[word_idx] == word
+            except:
+                raise Exception(
+                    f'Error, Mismatch\n=> "{word}" != [{word_idx}] of "{sentence}"'
+                )
 
-      word_time = {"start": subtitle["start"], "end": subtitle["end"], "index": word_idx, "word": word}
-      current_scene["timestamp"].append(word_time)
+            word_time = {
+                "start": subtitle["start"],
+                "end": subtitle["end"],
+                "index": word_idx,
+                "word": word,
+            }
+            current_scene["timestamp"].append(word_time)
 
-  for scene in scenes:
-    if len(scene["scene"].split(" ")) != len(scene["timestamp"]):
-      raise Exception("Error, Scene length and timestamp length doesnt match.")
-    if "" in scene["scene"].split(" "):
-      print(repr(scene["scene"]))
+    for scene in scenes:
+        if len(scene["scene"].split(" ")) != len(scene["timestamp"]):
+            raise Exception("Error, Scene length and timestamp length doesnt match.")
+        if "" in scene["scene"].split(" "):
+            print(repr(scene["scene"]))
 
-  full_script, full_scenes = [], []
-  for scene in scenes:
-    full_script += scene["scene"].split(" ")[:-1]
-    full_script.append(scene["scene"].split(" ")[-1]+"##")
-    full_scenes += scene["timestamp"]
+    full_script, full_scenes = [], []
+    for scene in scenes:
+        full_script += scene["scene"].split(" ")[:-1]
+        full_script.append(scene["scene"].split(" ")[-1] + "##")
+        full_scenes += scene["timestamp"]
 
-  for i, j in zip(full_script, full_scenes):
-    if i.replace("##", "") != j["word"]:
-      raise Exception("Error, Mismatch")
-      return
+    for i, j in zip(full_script, full_scenes):
+        if i.replace("##", "") != j["word"]:
+            raise Exception("Error, Mismatch")
+            return
+
+    assert len(full_scenes) == len(full_script)
+
+    return full_script, full_scenes
 
-  assert len(full_scenes) == len(full_script)
 
-  return full_script, full_scenes
-  
 def scene_from_new_script(raw_script, full_script, full_scenes):
-  mod_script = raw_script.replace("\n", " \n ").split(" ")
-  mod_script = [i for i in mod_script if i]
-  n = 0
-  while True:
-    if mod_script[n] == "\n":
-      mod_script[n-1] += "\n"
-      del(mod_script[n])
-      n -= 1
-    n += 1
-    if n == len(mod_script):
-      break
-  
-  print(f"Original: {len(full_script)}, Modded: {len(mod_script)}")
-  allowed_list = [".", "\n", "\n\n", ",", "?", "##"]
+    mod_script = raw_script.replace("\n", " \n ").split(" ")
+    mod_script = [i for i in mod_script if i]
+    n = 0
+    while True:
+        if mod_script[n] == "\n":
+            mod_script[n - 1] += "\n"
+            del mod_script[n]
+            n -= 1
+        n += 1
+        if n == len(mod_script):
+            break
+
+    print(f"Original: {len(full_script)}, Modded: {len(mod_script)}")
+    allowed_list = [".", "\n", "\n\n", ",", "?", "##"]
+
+    def normalized(x):
+        for i in allowed_list:
+            x = x.replace(i, "")
+        return x.upper()
+
+    same = lambda a, b: normalized(a) == normalized(b)
+    new_script, new_timestamp, orig_index, n = [], [], 0, 0
+    fail = 0
+    while n < len(mod_script):
+        print(f"{repr(mod_script[n]):>20} ? {repr(full_script[orig_index])}")
+        word = mod_script[n]
+        if same(word, full_script[orig_index].replace("##", "")):
+            cur = full_scenes[orig_index]
+            new_script.append(word.replace("##", ""))
+            new_timestamp.append({"start": cur["start"], "end": cur["end"]})
+            fail = 0
+        else:
+            if fail > 10:
+                raise Exception("Error: Failed to match words,")
+                return
+            fail += 1
+            n -= 1
+        n, orig_index = n + 1, orig_index + 1
+    assert len(new_script) == len(new_timestamp)
+    return new_script, new_timestamp
 
-  def normalized(x):
-    for i in allowed_list:
-      x = x.replace(i, "")
-    return x.upper()
-  
-  same = lambda a, b: normalized(a) == normalized(b)
-  new_script, new_timestamp, orig_index, n = [], [], 0, 0
-  fail = 0
-  while n < len(mod_script):
-    print(f"{repr(mod_script[n]):>20} ? {repr(full_script[orig_index])}")
-    word = mod_script[n]
-    if same(word, full_script[orig_index].replace("##", "")):
-      cur = full_scenes[orig_index]
-      new_script.append(word.replace("##", ""))
-      new_timestamp.append({"start": cur["start"], "end": cur["end"]})
-      fail = 0
-    else:
-      if fail > 10:
-        raise Exception("Error: Failed to match words,")
-        return
-      fail += 1
-      n -= 1
-    n, orig_index = n+1, orig_index+1
-  assert len(new_script) == len(new_timestamp)
-  return new_script, new_timestamp
 
 def build_new_subtitle(new_script, new_timestamp):
-  buffer, new_scenes, start, end = [], [], None, None
-  current_scene = []
- 
-  for i, j in zip(new_script, new_timestamp):
-    buffer.append(i.replace("\n", ""))
-    if not start:
-      start = j["start"]
+    buffer, new_scenes, start, end = [], [], None, None
+    current_scene = []
 
-    if "\n" in i:
-      current_scene.append({"content": " ".join(buffer).replace("##", ""), "start": start, "end": j["end"]})
-      buffer, start = [], None
- 
-    if "\n\n" in i:
-      print(f"Section break at line #{len(current_scene):<3}| \"{current_scene[-1]["content"]}\"")
-      new_scenes.append(current_scene)
-      current_scene = []
+    for i, j in zip(new_script, new_timestamp):
+        buffer.append(i.replace("\n", ""))
+        if not start:
+            start = j["start"]
 
-  if start:
-      buffer.append(i.replace("\n", ""))
-      current_scene.append({"content": " ".join(buffer), "start": start, "end": j["end"]})
+        if "\n" in i:
+            current_scene.append(
+                {
+                    "content": " ".join(buffer).replace("##", ""),
+                    "start": start,
+                    "end": j["end"],
+                }
+            )
+            buffer, start = [], None
 
-  if current_scene != (new_scenes[-1] if new_scenes else None):
-    new_scenes.append(current_scene)
+        if "\n\n" in i:
+            print(
+                f"Section break at line #{len(current_scene):<3}| \"{current_scene[-1]["content"]}\""
+            )
+            new_scenes.append(current_scene)
+            current_scene = []
 
-  newsub = []
-  for n, i in enumerate(new_scenes):
-    newsub += i
-    if n < len(new_scenes) - 1:
-      newsub.append({"content": "Break", "start": None, "end": None, "split": True})
+    if start:
+        buffer.append(i.replace("\n", ""))
+        current_scene.append(
+            {"content": " ".join(buffer), "start": start, "end": j["end"]}
+        )
+
+    if current_scene != (new_scenes[-1] if new_scenes else None):
+        new_scenes.append(current_scene)
+
+    newsub = []
+    for n, i in enumerate(new_scenes):
+        newsub += i
+        if n < len(new_scenes) - 1:
+            newsub.append(
+                {"content": "Break", "start": None, "end": None, "split": True}
+            )
+
+    return newsub
 
-  return newsub
 
 ###
 
+
 def autobreak(lines, times):
-  from datetime import timedelta
+    from datetime import timedelta
 
-  def parsetime(time_str):
-    minutes, seconds = time_str.split(':')
-    seconds, milliseconds = seconds.split('.')
-    td = timedelta(minutes=int(minutes), seconds=int(seconds), milliseconds=int(milliseconds))
-    return td
+    def parsetime(time_str):
+        minutes, seconds = time_str.split(":")
+        seconds, milliseconds = seconds.split(".")
+        td = timedelta(
+            minutes=int(minutes), seconds=int(seconds), milliseconds=int(milliseconds)
+        )
+        return td
 
-  script = []
-  long_breaks = []
-  tmark = parsetime("0:0.0")
-  for i, j in zip(lines, times):
-    tdiff = parsetime(j["start"]) - tmark
-    tmark = parsetime(j["end"])
-    if tdiff > parsetime("0:0.0"):
-      long_breaks.append(tdiff)
+    script = []
+    long_breaks = []
+    tmark = parsetime("0:0.0")
+    for i, j in zip(lines, times):
+        tdiff = parsetime(j["start"]) - tmark
+        tmark = parsetime(j["end"])
+        if tdiff > parsetime("0:0.0"):
+            long_breaks.append(tdiff)
 
-  mean_break = parsetime("0:0.0")
-  for i in long_breaks:
-    mean_break += i/len(long_breaks)
-  print(mean_break)
+    mean_break = parsetime("0:0.0")
+    for i in long_breaks:
+        mean_break += i / len(long_breaks)
+    print(mean_break)
 
-  script = ""
-  tmark = parsetime("0:0.0")
-  tmp = " "
+    script = ""
+    tmark = parsetime("0:0.0")
+    tmp = " "
 
-  continous_line = 0
-  for i, j in zip(lines, times):
-    tdiff = parsetime(j["start"]) - tmark
-    tmark = parsetime(j["end"])
-    if tdiff > mean_break and tmp[-1] != ".":
-      script += "\n"
+    continous_line = 0
+    for i, j in zip(lines, times):
+        tdiff = parsetime(j["start"]) - tmark
+        tmark = parsetime(j["end"])
+        if tdiff > mean_break and tmp[-1] != ".":
+            script += "\n"
 
-    if (tdiff >= mean_break and tmp[-1] == "."):
-        script += "\n"
-        continous_line = 0
-    else:
-      continous_line += 1
+        if tdiff >= mean_break and tmp[-1] == ".":
+            script += "\n"
+            continous_line = 0
+        else:
+            continous_line += 1
 
-    script += i.replace("##", "")
+        script += i.replace("##", "")
+
+        if i[-1] == ".":
+            script += "\n"
+        elif "##" in i:
+            script += "\n"
+        else:
+            script += " "
+        tmp = i
+
+    return script
 
-    if i[-1] == ".":
-      script += "\n"
-    elif "##" in i:
-        script += "\n"
-    else:
-      script += " " 
-    tmp = i
-  
-  return script
 
 ############################################
 
-def saveFile(filename, data, override = False):
-  if os.path.exists(filename) and not override:
-    raise Exception(f"File {filename} already exists.")
-    return
-  with open(filename, "w") as f:
-    f.write(data)
+
+def saveFile(filename, data, override=False):
+    if os.path.exists(filename) and not override:
+        raise Exception(f"File {filename} already exists.")
+        return
+    with open(filename, "w") as f:
+        f.write(data)
+
 
 def openFile(filename):
-  if not os.path.exists(filename):
-    raise Exception(f"File {filename} doesnt exists.")
-    return
-  with open(filename, "r") as f:
-    data = f.read()
-  if not data:
-    raise Exception("Data empty.")
-    return
-  return data
+    if not os.path.exists(filename):
+        raise Exception(f"File {filename} doesnt exists.")
+        return
+    with open(filename, "r") as f:
+        data = f.read()
+    if not data:
+        raise Exception("Data empty.")
+        return
+    return data
+
 
 ############################################
 
-if __name__=="__main__":
-  PROG = sys.argv[0].split("/")[-1]
-  if len(sys.argv) not in (3, 4):
-    print( \
-f"""Usage: {PROG} [COMMAND] [FILES]...
+if __name__ == "__main__":
+    PROG = sys.argv[0].split("/")[-1]
+    if len(sys.argv) not in (3, 4):
+        print(
+            f"""Usage: {PROG} [COMMAND] [FILES]...
 
 Commands:
  - script   <VTT file>                    Generates script file from vtt file.
  - apply    <VTT file> <script file>      Applies new scripted file to create JSON file.
  - create   <JSON file>                   Creates new vtt from given JSON.
- """)                              
-    sys.exit()
+ """
+        )
+        sys.exit()
 
-  COMMAND = sys.argv[1]
-  if COMMAND not in ["script", "apply", "create"]:
-    print("Error. Command not found.")
-    sys.exit()
+    COMMAND = sys.argv[1]
+    if COMMAND not in ["script", "apply", "create"]:
+        print("Error. Command not found.")
+        sys.exit()
 
-  print(f"-> {sys.argv}")
-  if COMMAND == "script":
-    FILE = sys.argv[2]
-    if (not os.path.exists(FILE)):
-      print(f"Input file doesnt exists.")
-      sys.exit(-1)
+    print(f"-> {sys.argv}")
+    if COMMAND == "script":
+        FILE = sys.argv[2]
+        if not os.path.exists(FILE):
+            print(f"Input file doesnt exists.")
+            sys.exit(-1)
 
-    modfile = ".".join(scriptfile.split(".")[:-1]) + ".script"
-    x = create_word_scenes(openFile(FILE), "\n".join(script_from_word_vtt(openFile(FILE))))
-    if not x:
-      sys.exit(-1)
+        modfile = ".".join(scriptfile.split(".")[:-1]) + ".script"
+        x = create_word_scenes(
+            openFile(FILE), "\n".join(script_from_word_vtt(openFile(FILE)))
+        )
+        if not x:
+            sys.exit(-1)
 
-    full_script, full_scenes = x
-    genscript = autobreak(full_script, full_scenes)
-    saveFile(modfile, genscript)
-    print(f"Saved script file {modfile}.")
-  
-  elif COMMAND == "apply":
-    if len(sys.argv) != 4:
-      print(f"Not sufficient input.")
-      sys.exit()
+        full_script, full_scenes = x
+        genscript = autobreak(full_script, full_scenes)
+        saveFile(modfile, genscript)
+        print(f"Saved script file {modfile}.")
 
-    FILE1, FILE2 = sys.argv[2], sys.argv[3]
-    if (not os.path.exists(FILE1)) or (not os.path.exists(FILE2)):
-      print(f"Input file doesnt exists.")
-      sys.exit(-1)
+    elif COMMAND == "apply":
+        if len(sys.argv) != 4:
+            print(f"Not sufficient input.")
+            sys.exit()
 
-    x = create_word_scenes(openFile(FILE1), "\n".join(script_from_word_vtt(openFile(FILE1))))
-    if not x:
-      sys.exit(-1)
-    full_script, full_scenes = x
+        FILE1, FILE2 = sys.argv[2], sys.argv[3]
+        if (not os.path.exists(FILE1)) or (not os.path.exists(FILE2)):
+            print(f"Input file doesnt exists.")
+            sys.exit(-1)
 
-    x = scene_from_new_script(openFile(FILE2), full_script, full_scenes)
-    if not x:
-      sys.exit(-1)
-    a, b = x
+        x = create_word_scenes(
+            openFile(FILE1), "\n".join(script_from_word_vtt(openFile(FILE1)))
+        )
+        if not x:
+            sys.exit(-1)
+        full_script, full_scenes = x
 
-    final_sub = build_new_subtitle(a, b)
-    jsonfile = ".".join(FILE1.split(".")[:-1]) + ".json"
-    saveFile(jsonfile, json.dumps(final_sub, indent=2), True)
-    print(f"Saved JSON file {jsonfile}.")
-    sys.exit(0)
-  
-  elif COMMAND == "create":
-    FILE = sys.argv[2]
-    if (not os.path.exists(FILE)):
-      print(f"Input file doesnt exists.")
-      sys.exit(-1)
+        x = scene_from_new_script(openFile(FILE2), full_script, full_scenes)
+        if not x:
+            sys.exit(-1)
+        a, b = x
 
-    final_vtt = json.loads(openFile(FILE))
-    orgf = ".".join(FILE.split(".")[:-1])
-    print(f"Saved VTT file as {orgf}.final.vtt.")
+        final_sub = build_new_subtitle(a, b)
+        jsonfile = ".".join(FILE1.split(".")[:-1]) + ".json"
+        saveFile(jsonfile, json.dumps(final_sub, indent=2), True)
+        print(f"Saved JSON file {jsonfile}.")
+        sys.exit(0)
 
-    if os.path.exists(orgf + ".vtt"):
-      saveFile(orgf + ".stacked.vtt", to_stacked_vtt(final_vtt), True)
-    else:
-      saveFile(orgf + ".vtt", to_stacked_vtt(final_vtt), True)
-    sys.exit(0)
\ No newline at end of file
+    elif COMMAND == "create":
+        FILE = sys.argv[2]
+        if not os.path.exists(FILE):
+            print(f"Input file doesnt exists.")
+            sys.exit(-1)
+
+        final_vtt = json.loads(openFile(FILE))
+        orgf = ".".join(FILE.split(".")[:-1])
+        print(f"Saved VTT file as {orgf}.final.vtt.")
+
+        if os.path.exists(orgf + ".vtt"):
+            saveFile(orgf + ".stacked.vtt", to_stacked_vtt(final_vtt), True)
+        else:
+            saveFile(orgf + ".vtt", to_stacked_vtt(final_vtt), True)
+        sys.exit(0)
diff --git a/stackvtt.py b/stackvtt.py
index 5c6e58b..2607f3d 100644
--- a/stackvtt.py
+++ b/stackvtt.py
@@ -1,18 +1,21 @@
 import re
 from datetime import timedelta
 
-VTT_TIMECODE_PATTERN = r"((?:\d{2}:)?\d{2}:\d{2}\.\d{3}) --> ((?:\d{2}:)?\d{2}:\d{2}\.\d{3})"
+VTT_TIMECODE_PATTERN = (
+    r"((?:\d{2}:)?\d{2}:\d{2}\.\d{3}) --> ((?:\d{2}:)?\d{2}:\d{2}\.\d{3})"
+)
 VTT_LINE_NUMBER_PATTERN = r"^\d+$"
 
-def from_vtt(vtt_string):
-    parts = re.split(r'\n\n+', vtt_string.strip())
 
-    if parts[0].startswith('WEBVTT'):
+def from_vtt(vtt_string):
+    parts = re.split(r"\n\n+", vtt_string.strip())
+
+    if parts[0].startswith("WEBVTT"):
         parts.pop(0)
 
     subtitles = []
     for part in parts:
-        lines = part.split('\n')
+        lines = part.split("\n")
         match = re.match(VTT_TIMECODE_PATTERN, lines[0])
         if not match:
             if re.match(VTT_LINE_NUMBER_PATTERN, lines[0]):
@@ -22,30 +25,28 @@ def from_vtt(vtt_string):
             continue
 
         start, end = match.groups()
-        content = '\n'.join(lines[1:])
+        content = "\n".join(lines[1:])
 
-        subtitles.append({
-            'start': start,
-            'end': end,
-            'content': content
-        })
+        subtitles.append({"start": start, "end": end, "content": content})
 
     return subtitles
 
+
 def to_vtt(subtitles):
     vtt_content = "WEBVTT\n\n"
     for idx, subtitle in enumerate(subtitles):
-        start = subtitle['start']
-        end = subtitle['end']
-        content = subtitle['content']
+        start = subtitle["start"]
+        end = subtitle["end"]
+        content = subtitle["content"]
         vtt_content += f"{start} --> {end}\n{content}\n\n"
     return vtt_content.strip()
 
+
 def stack_subtitle():
     buffer = []
     linebuf = []
     for line in parsed_vtt:
-        print(line["content"].strip()) 
+        print(line["content"].strip())
         content = line["content"].strip()
         if True:
             linebuf.append(line)
@@ -62,12 +63,13 @@ def stack_subtitle():
             # if scene["content"][-1] == ".":
             strbuf += "\n"
             # else:
-                # strbuf += " "
+            # strbuf += " "
             scene["content"] = strbuf
             sub.append(scene)
 
+
 with open("example.vtt", "r") as f:
     vtt_content = f.read()
 
 parsed_vtt = from_vtt(vtt_content)
-print(to_vtt(stack_subtitle(parsed_vtt)))
\ No newline at end of file
+print(to_vtt(stack_subtitle(parsed_vtt)))
diff --git a/subedit.py b/subedit.py
index 7120b60..85a5b0e 100644
--- a/subedit.py
+++ b/subedit.py
@@ -1,79 +1,88 @@
 import json
 import os, sys
 
-def readFile(file):
-  if not os.path.exists(file):
-    raise Exception(f"File {file} doesn't exists.")
-  with open(file, "r") as f:
-    data = f.read()
-  return data
 
-def writeFile(file, data, overwrite = False):
-  if (not overwrite) and os.path.exists(file):
-    raise Exception(f"File {file} already exists.")
-  if not len(data):
-    raise Exception(f"Tried to write empty data.")
-  with open(file, "w") as f:
-    ret = f.write(data)
-  return ret
+def readFile(file):
+    if not os.path.exists(file):
+        raise Exception(f"File {file} doesn't exists.")
+    with open(file, "r") as f:
+        data = f.read()
+    return data
+
+
+def writeFile(file, data, overwrite=False):
+    if (not overwrite) and os.path.exists(file):
+        raise Exception(f"File {file} already exists.")
+    if not len(data):
+        raise Exception(f"Tried to write empty data.")
+    with open(file, "w") as f:
+        ret = f.write(data)
+    return ret
+
 
 file = sys.argv[1]
 
 if ".json" in file:
-  subtitles = json.loads(readFile(file))
-  output = ""
-  index = 0
-  for subtitle in subtitles:
-    if subtitle.get("split", False):
-      output += "\n"
-    else:
-      index += 1
-      start = subtitle["start"]
-      end = subtitle["end"]
-      content = subtitle["content"]
-      "| {start:>10} --> {end:>10} |"
-      output += f"{index:03} | {content.strip()}\n"
+    subtitles = json.loads(readFile(file))
+    output = ""
+    index = 0
+    for subtitle in subtitles:
+        if subtitle.get("split", False):
+            output += "\n"
+        else:
+            index += 1
+            start = subtitle["start"]
+            end = subtitle["end"]
+            content = subtitle["content"]
+            "| {start:>10} --> {end:>10} |"
+            output += f"{index:03} | {content.strip()}\n"
 
-  output += "############ TIMESTAMPS ############\n\n"
+    output += "############ TIMESTAMPS ############\n\n"
 
-  index = 0
-  for subtitle in subtitles:
-    if not subtitle.get("split", False):
-      index += 1
-      start = subtitle["start"]
-      end = subtitle["end"]
-      output += f"{index:03} | {start} --> {end} \n"
+    index = 0
+    for subtitle in subtitles:
+        if not subtitle.get("split", False):
+            index += 1
+            start = subtitle["start"]
+            end = subtitle["end"]
+            output += f"{index:03} | {start} --> {end} \n"
 
-  writeFile(os.path.splitext(file)[0]+".edit", output)
+    writeFile(os.path.splitext(file)[0] + ".edit", output)
 
 elif ".edit" in file:
-  subtitles = json.loads(readFile(os.path.splitext(file)[0]+".json"))
-  lines = readFile(file)
+    subtitles = json.loads(readFile(os.path.splitext(file)[0] + ".json"))
+    lines = readFile(file)
 
-  idx, sub = 0, {}
-  for subtitle in subtitles:
-    if not subtitle.get("split", False):
-      sub[idx] = subtitle
-      idx += 1
+    idx, sub = 0, {}
+    for subtitle in subtitles:
+        if not subtitle.get("split", False):
+            sub[idx] = subtitle
+            idx += 1
 
-  new_brk, new_sub = [], {}
-  for line in lines.split("\n"):
-    if "\n############ TIMESTAMPS ############" == line:
-      break
-    if line:
-      idx, content = line.split(" | ")
-      idx = int(idx) - 1
-      if sub[idx]["content"] != content:
-        print(f"{idx} {sub[idx]["content"]} -> {content}")
-      new_sub[idx] = {"content": content, "start": sub[idx]["start"], "end": sub[idx]["end"]}
-    else:
-      new_brk.append(idx)
+    new_brk, new_sub = [], {}
+    for line in lines.split("\n"):
+        if "\n############ TIMESTAMPS ############" == line:
+            break
+        if line:
+            idx, content = line.split(" | ")
+            idx = int(idx) - 1
+            if sub[idx]["content"] != content:
+                print(f"{idx} {sub[idx]["content"]} -> {content}")
+            new_sub[idx] = {
+                "content": content,
+                "start": sub[idx]["start"],
+                "end": sub[idx]["end"],
+            }
+        else:
+            new_brk.append(idx)
 
-  output = []
-  for n in sorted(new_sub):
-    subtitle = new_sub[n]
-    output.append(subtitle)
-    if n in new_brk:
-      output.append({"content": "Break", "start": None, "end": None, "split": True})
+    output = []
+    for n in sorted(new_sub):
+        subtitle = new_sub[n]
+        output.append(subtitle)
+        if n in new_brk:
+            output.append(
+                {"content": "Break", "start": None, "end": None, "split": True}
+            )
 
-  writeFile(os.path.splitext(file)[0]+".json.1", json.dumps(output, indent=2))
\ No newline at end of file
+    writeFile(os.path.splitext(file)[0] + ".json.1", json.dumps(output, indent=2))
diff --git a/vttmaker.py b/vttmaker.py
index 6b75388..d808405 100644
--- a/vttmaker.py
+++ b/vttmaker.py
@@ -7,7 +7,7 @@ from tkinter import messagebox
 import vlc
 import time, sys
 
-vlc_instance = vlc.Instance('--verbose=0')
+vlc_instance = vlc.Instance("--verbose=0")
 player = vlc_instance.media_player_new()
 
 audio_started = False
@@ -20,6 +20,7 @@ MediaTotalLength = 0
 
 stdout_buf = []
 
+
 class TextRedirector(object):
     def __init__(self, buf, origin):
         self.buffer = buf
@@ -32,122 +33,143 @@ class TextRedirector(object):
     def flush(self):
         self.origin.flush()
 
-def toggle_audio(event = None):
-  global audio_started
-  if not audio_started:
-    print("Audio Play.")
-    player.play()
-    audio_started = True
-  elif player.is_playing():
-    print("Audio Pause.")
-    player.pause()
-  else:
-    print("Audio Play.")
-    player.play()
 
-def rewind_audio(event = None):
-  new_time = max(player.get_time() - 5000, 0)
-  player.set_time(new_time)
+def toggle_audio(event=None):
+    global audio_started
+    if not audio_started:
+        print("Audio Play.")
+        player.play()
+        audio_started = True
+    elif player.is_playing():
+        print("Audio Pause.")
+        player.pause()
+    else:
+        print("Audio Play.")
+        player.play()
+
+
+def rewind_audio(event=None):
+    new_time = max(player.get_time() - 5000, 0)
+    player.set_time(new_time)
+
+
+def fastforward_audio(event=None):
+    new_time = player.get_time() + 5000
+    player.set_time(new_time)
 
-def fastforward_audio(event = None):
-  new_time = player.get_time() + 5000
-  player.set_time(new_time)
 
 def mark_start():
-  print(line_index)
-  timestamp = player.get_time() / 1000.0
-  current_subtitle["start"] = timestamp
-  if line_index > len(script_lines) or not len(script_lines):
-    print("Please load first..")
-    return
-  if line_index > len(script_lines) - 1:
-    messagebox.showerror("Error", "No more subtitle.")
-    current_subtitle["start"] = None
-    return
-  current_subtitle["content"] =  script_lines[line_index]
-  current_subtitle["index"] = line_index
-  update_display()
-  print(f"\n{timestamp} --> ", end="")
+    print(line_index)
+    timestamp = player.get_time() / 1000.0
+    current_subtitle["start"] = timestamp
+    if line_index > len(script_lines) or not len(script_lines):
+        print("Please load first..")
+        return
+    if line_index > len(script_lines) - 1:
+        messagebox.showerror("Error", "No more subtitle.")
+        current_subtitle["start"] = None
+        return
+    current_subtitle["content"] = script_lines[line_index]
+    current_subtitle["index"] = line_index
+    update_display()
+    print(f"\n{timestamp} --> ", end="")
+
 
 def mark_end():
-  if current_subtitle.get("content") == None:
-    print("Please load first..")
-    return
-  timestamp = player.get_time() / 1000.0
-  current_subtitle["end"] = timestamp
-  subtitles.append(current_subtitle.copy())
-  print(f"{current_subtitle["end"]}\n{current_subtitle["content"]}")
-  current_subtitle["content"] = ""
-  current_subtitle["start"] = None
-  load_next_line()
-  update_display()
-
-def on_next_press(event = None):
-  if current_subtitle.get("start") is None:
-    mark_start()
-  else:
-    mark_end()
-
-def on_autonext_press(event = None):
-  if current_subtitle.get("start") is None:
-    mark_start()
-  else:
-    mark_end()
-    mark_start()
-
-def on_done_press(event = None):
-  if line_index < 1:
-    return
-  if current_subtitle["start"] != None:
-    mark_end()
-  subtitles.append({"start": None,"end": None,"content": None,"split": True})
-  scene_breaks.append(line_index)
-  update_display()
-    
-def on_back(event = None):
-  global subtitles
-  if len(subtitles) == 0:
-    messagebox.showerror("Error", f"No subtitle to remove.")
-    return
-  if current_subtitle["start"]:
-    if not messagebox.askokcancel("Warning", f"\nDeleting current #{current_subtitle.get("index")}.\n You need to go back and mark start again."):
-      return
+    if current_subtitle.get("content") == None:
+        print("Please load first..")
+        return
+    timestamp = player.get_time() / 1000.0
+    current_subtitle["end"] = timestamp
+    subtitles.append(current_subtitle.copy())
+    print(f"{current_subtitle["end"]}\n{current_subtitle["content"]}")
     current_subtitle["content"] = ""
-    if len(subtitles) > 1:
-      current_subtitle["content"] = subtitles[-1]["content"] + "\n"
     current_subtitle["start"] = None
-  else:
-    if not messagebox.askokcancel("Warning", f"\nDeleting previous #{subtitles[-1].get("index")}.\n You need to go back and mark start again."):
-      return
-    del(subtitles[-1])
-    current_subtitle["content"] = ""
-    if len(subtitles) > 2:
-      current_subtitle["content"] = subtitles[-1]["content"] + "\n"
-    current_subtitle["start"] = None
-  print(f"\nCurrent: #{len(subtitles)+1} {current_subtitle}")
-  load_next_line(diff = -1)
+    load_next_line()
+    update_display()
+
+
+def on_next_press(event=None):
+    if current_subtitle.get("start") is None:
+        mark_start()
+    else:
+        mark_end()
+
+
+def on_autonext_press(event=None):
+    if current_subtitle.get("start") is None:
+        mark_start()
+    else:
+        mark_end()
+        mark_start()
+
+
+def on_done_press(event=None):
+    if line_index < 1:
+        return
+    if current_subtitle["start"] != None:
+        mark_end()
+    subtitles.append({"start": None, "end": None, "content": None, "split": True})
+    scene_breaks.append(line_index)
+    update_display()
+
+
+def on_back(event=None):
+    global subtitles
+    if len(subtitles) == 0:
+        messagebox.showerror("Error", f"No subtitle to remove.")
+        return
+    if current_subtitle["start"]:
+        if not messagebox.askokcancel(
+            "Warning",
+            f"\nDeleting current #{current_subtitle.get("index")}.\n You need to go back and mark start again.",
+        ):
+            return
+        current_subtitle["content"] = ""
+        if len(subtitles) > 1:
+            current_subtitle["content"] = subtitles[-1]["content"] + "\n"
+        current_subtitle["start"] = None
+    else:
+        if not messagebox.askokcancel(
+            "Warning",
+            f"\nDeleting previous #{subtitles[-1].get("index")}.\n You need to go back and mark start again.",
+        ):
+            return
+        del subtitles[-1]
+        current_subtitle["content"] = ""
+        if len(subtitles) > 2:
+            current_subtitle["content"] = subtitles[-1]["content"] + "\n"
+        current_subtitle["start"] = None
+    print(f"\nCurrent: #{len(subtitles)+1} {current_subtitle}")
+    load_next_line(diff=-1)
+
 
 def update_timestamp():
-  current_pos = max(player.get_time() / 1000, 0)
-  timestamp_label.config(text=f"{to_time(current_pos, True)} / {to_time(MediaTotalLength, True)}")
-  root.after(200, update_timestamp)
+    current_pos = max(player.get_time() / 1000, 0)
+    timestamp_label.config(
+        text=f"{to_time(current_pos, True)} / {to_time(MediaTotalLength, True)}"
+    )
+    root.after(200, update_timestamp)
+
 
 def multiline(content):
-  return content.strip()
-  if content:
-    return "- " + content.strip().replace("\n", "\n- ")
+    return content.strip()
+    if content:
+        return "- " + content.strip().replace("\n", "\n- ")
+
+
+def to_time(seconds, hide=False):
+    minutes = int(seconds // 60)
+    second = seconds % 60
+    hours = int(minutes // 60)
+    minute = minutes % 60
+    if hide:
+        if minutes > 60:
+            return f"{hours}:{minute:02}:{second:06.3f}"
+        else:
+            return f"{minute:02}:{second:06.3f}"
+    return f"{hours}:{minute:02}:{second:06.3f}"
 
-def to_time(seconds, hide = False):
-  minutes = int(seconds // 60)
-  second = seconds % 60
-  hours = int(minutes // 60)
-  minute = minutes % 60
-  if hide:
-    if minutes > 60:
-      return f"{hours}:{minute:02}:{second:06.3f}"
-    else:
-      return f"{minute:02}:{second:06.3f}"
-  return f"{hours}:{minute:02}:{second:06.3f}"
 
 def update_display():
     listbox_scroll_pos = script_listbox.yview()
@@ -166,61 +188,65 @@ def update_display():
             lstart = subtitles[n]["start"]
             lend = subtitles[n]["end"]
             if lstart:
-              subtitle_display = f"{subtitles[n]["index"]}\n{to_time(lstart)} --> {to_time(lend)}\n{multiline(subtitles[n]['content']).replace("\n", "↵\n")} \n\n"
+                subtitle_display = f"{subtitles[n]["index"]}\n{to_time(lstart)} --> {to_time(lend)}\n{multiline(subtitles[n]['content']).replace("\n", "↵\n")} \n\n"
             else:
-              scene_breaks.append(subtitles[n-1]["index"])
-              print(f"End section at idx {subtitles[n-1]["index"]}, {to_time(subtitles[n-1]["end"])}")
-              subtitle_display = f"----------\n\n"  
-            subtitle_text.insert(tk.END, subtitle_display)
-        
-        elif n == len(subtitles) :
-          lstart = current_subtitle.get("start", "")
-          if lstart:
-            subtitle_display = f"{subtitles[n]["index"]}\n{to_time(lstart)} -> \n{multiline(current_subtitle.get('content').replace("\n", "↵\n"))} \n\n"
+                scene_breaks.append(subtitles[n - 1]["index"])
+                print(
+                    f"End section at idx {subtitles[n-1]["index"]}, {to_time(subtitles[n-1]["end"])}"
+                )
+                subtitle_display = f"----------\n\n"
             subtitle_text.insert(tk.END, subtitle_display)
 
+        elif n == len(subtitles):
+            lstart = current_subtitle.get("start", "")
+            if lstart:
+                subtitle_display = f"{subtitles[n]["index"]}\n{to_time(lstart)} -> \n{multiline(current_subtitle.get('content').replace("\n", "↵\n"))} \n\n"
+                subtitle_text.insert(tk.END, subtitle_display)
+
     list_color = 0
     for n, line in enumerate(script_lines):
         display_line = " " + line
         script_listbox.insert(tk.END, f"{n:03} " + display_line)
-        if n-1 in scene_breaks:
-          print(f"New section from {n}")
-          list_color = ~list_color
+        if n - 1 in scene_breaks:
+            print(f"New section from {n}")
+            list_color = ~list_color
         if n == line_index:
-            script_listbox.itemconfig(n, {'bg': 'lightgrey'})
+            script_listbox.itemconfig(n, {"bg": "lightgrey"})
 
         if n < line_index:
-          if list_color:
-            script_listbox.itemconfig(n, {'bg': '#FFEFFF'})
-          else:
-            script_listbox.itemconfig(n, {'bg': '#FFFFEF'})
+            if list_color:
+                script_listbox.itemconfig(n, {"bg": "#FFEFFF"})
+            else:
+                script_listbox.itemconfig(n, {"bg": "#FFFFEF"})
 
     if player.is_playing() or not audio_started:
-      script_listbox.see(min(line_index + 5, len(script_lines)))
-      subtitle_text.see(tk.END)
+        script_listbox.see(min(line_index + 5, len(script_lines)))
+        subtitle_text.see(tk.END)
     else:
-      script_listbox.yview_moveto(listbox_scroll_pos[0])
-      subtitle_text.see(text_scroll_index)
+        script_listbox.yview_moveto(listbox_scroll_pos[0])
+        subtitle_text.see(text_scroll_index)
 
-    info_label.config(text="[ Current stack ]\n" + current_subtitle.get('content', ""))
+    info_label.config(text="[ Current stack ]\n" + current_subtitle.get("content", ""))
 
     subtitle_text.config(state=tk.DISABLED)
 
-def load_next_line(diff = 1):
-  global line_index
-  print(line_index, len(script_lines))
 
-  if (line_index < len(script_lines) - 1) or (diff < 0):
-    line_index += diff
-    update_display()
-    return
-    
-  elif line_index == len(script_lines) - 1:
-    line_index += 1
-    update_display()
-    if player.is_playing():
-      player.pause()
-    messagebox.showerror("Error", f"No more subtitle.")
+def load_next_line(diff=1):
+    global line_index
+    print(line_index, len(script_lines))
+
+    if (line_index < len(script_lines) - 1) or (diff < 0):
+        line_index += diff
+        update_display()
+        return
+
+    elif line_index == len(script_lines) - 1:
+        line_index += 1
+        update_display()
+        if player.is_playing():
+            player.pause()
+        messagebox.showerror("Error", f"No more subtitle.")
+
 
 def load_file(label):
     file_path = filedialog.askopenfilename()
@@ -229,6 +255,7 @@ def load_file(label):
         return file_path
     return None
 
+
 def choose_audio():
     global player, MediaTotalLength
     file_path = load_file(audio_label)
@@ -236,82 +263,114 @@ def choose_audio():
         player.set_media(media := vlc.Media(file_path))
         media.parse_with_options(vlc.MediaParseFlag.fetch_network, 0)
         while not media.is_parsed():
-          time.sleep(0.1)
-        MediaTotalLength = (media.get_duration() // 1000)
+            time.sleep(0.1)
+        MediaTotalLength = media.get_duration() // 1000
         print(f"Media loaded {file_path} length {MediaTotalLength}")
 
+
 def choose_script():
     global script_lines, line_index, current_subtitle
     file_path = load_file(script_label)
     if file_path:
-        script_lines = open(file_path, 'r').read().splitlines()
+        script_lines = open(file_path, "r").read().splitlines()
         subtitles.clear()
         line_index, current_subtitle = 0, {}
         print(f"Script loaded {file_path}")
         update_display()
 
+
 def save_subtitles():
-    vtt_path = filedialog.asksaveasfilename(defaultextension=".vtt", filetypes=[("VTT files", "*.vtt"), ("All files", "*.*")])
+    vtt_path = filedialog.asksaveasfilename(
+        defaultextension=".vtt",
+        filetypes=[("VTT files", "*.vtt"), ("All files", "*.*")],
+    )
     if vtt_path:
-        with open(vtt_path, 'w') as f:
-            f.write('WEBVTT\n\n')
+        with open(vtt_path, "w") as f:
+            f.write("WEBVTT\n\n")
             for subtitle in subtitles:
-                f.write(f"{to_time(subtitle['start'])} --> {to_time(subtitle['end'])}\n")
-                f.write(multiline(subtitle['content']))
+                f.write(
+                    f"{to_time(subtitle['start'])} --> {to_time(subtitle['end'])}\n"
+                )
+                f.write(multiline(subtitle["content"]))
                 f.write("\n\n")
 
     print(f"Done saving {len(subtitles)} subtitles")
 
+
 def save_stacked_subtitles():
-    vtt_path = filedialog.asksaveasfilename(defaultextension=".vtt", filetypes=[("VTT files", "*.vtt"), ("All files", "*.*")])
+    vtt_path = filedialog.asksaveasfilename(
+        defaultextension=".vtt",
+        filetypes=[("VTT files", "*.vtt"), ("All files", "*.*")],
+    )
     if vtt_path:
-        with open(vtt_path, 'w') as f:
-            f.write('WEBVTT\n\n\n')
+        with open(vtt_path, "w") as f:
+            f.write("WEBVTT\n\n\n")
             buffer = ""
             for subtitle in subtitles:
                 if subtitle.get("split", False):
-                  buffer = ""
-                  continue
+                    buffer = ""
+                    continue
 
                 if len(buffer) != 0:
-                  if str(subtitle['content'].strip())[-1] == ".":
-                    buffer += "\n"
-                  else:
-                    buffer += " "
+                    if str(subtitle["content"].strip())[-1] == ".":
+                        buffer += "\n"
+                    else:
+                        buffer += " "
 
-                buffer += multiline(subtitle['content'])
+                buffer += multiline(subtitle["content"])
 
-                f.write(f"{to_time(subtitle['start'])} --> {to_time(subtitle['end'])}\n")
+                f.write(
+                    f"{to_time(subtitle['start'])} --> {to_time(subtitle['end'])}\n"
+                )
                 f.write(buffer)
                 f.write("\n\n\n")
 
     print(f"Done saving {len(subtitles)} subtitles (stacking)")
 
+
 def save_prog():
-  import json
-  fpath = filedialog.asksaveasfilename(defaultextension=".json", filetypes=[("JSON files", "*.json"), ("All files", "*.*")])
-  if fpath:
-      with open(fpath, 'w') as f:
-        f.write(json.dumps({"subtitles": subtitles, "script_lines": script_lines,"line_index": line_index,"current_subtitle": current_subtitle, "play": player.get_time()}, indent=2))
-     
+    import json
+
+    fpath = filedialog.asksaveasfilename(
+        defaultextension=".json",
+        filetypes=[("JSON files", "*.json"), ("All files", "*.*")],
+    )
+    if fpath:
+        with open(fpath, "w") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "subtitles": subtitles,
+                        "script_lines": script_lines,
+                        "line_index": line_index,
+                        "current_subtitle": current_subtitle,
+                        "play": player.get_time(),
+                    },
+                    indent=2,
+                )
+            )
+
+
 def load_prog():
-  global subtitles, player, script_lines, line_index, current_subtitle
-  import json
-  fpath = filedialog.askopenfilename()    
-  if fpath:
-    with open(fpath, 'r') as f:
-      back = json.loads(f.read())
-    subtitles = back["subtitles"]
-    script_lines = back["script_lines"]
-    line_index = back["line_index"]
-    current_subtitle = back["current_subtitle"]
-    curpos = int(back["play"])
-    messagebox.showinfo("Loaded", f"Loaded {len(subtitles)} subtitles.")
-    player.play()
-    player.set_time(curpos)
-    time.sleep(0.3)
-    player.pause()
-    update_display()
+    global subtitles, player, script_lines, line_index, current_subtitle
+    import json
+
+    fpath = filedialog.askopenfilename()
+    if fpath:
+        with open(fpath, "r") as f:
+            back = json.loads(f.read())
+        subtitles = back["subtitles"]
+        script_lines = back["script_lines"]
+        line_index = back["line_index"]
+        current_subtitle = back["current_subtitle"]
+        curpos = int(back["play"])
+        messagebox.showinfo("Loaded", f"Loaded {len(subtitles)} subtitles.")
+        player.play()
+        player.set_time(curpos)
+        time.sleep(0.3)
+        player.pause()
+        update_display()
+
 
 def skip_to_time():
     try:
@@ -324,125 +383,140 @@ def skip_to_time():
     except Exception as e:
         print(e)
 
+
 def on_list_right_click(event):
     try:
         context_menu.tk_popup(event.x_root, event.y_root)
     finally:
         context_menu.grab_release()
 
+
 def on_left_click(event):
-  context_menu.unpost()
+    context_menu.unpost()
+
 
 def on_list_left_click(event):
-  if player.is_playing():
-    player.pause()
-  on_left_click(event)
+    if player.is_playing():
+        player.pause()
+    on_left_click(event)
 
-def merge_selected(event = None):
+
+def merge_selected(event=None):
     selected_indices = script_listbox.curselection()
     if not selected_indices:
         messagebox.showinfo("No selection", "Please select items to merge.")
         return
-    
+
     if len(selected_indices) == 1:
-        messagebox.showinfo("Not enough selection", "Please select multiple item to merge.")
+        messagebox.showinfo(
+            "Not enough selection", "Please select multiple item to merge."
+        )
         return
 
     selected_lines = [script_lines[i] for i in selected_indices]
     print("Merge", selected_lines)
-    merged_line = ' '.join(selected_lines)
-    
+    merged_line = " ".join(selected_lines)
+
     script_lines[selected_indices[0]] = merged_line
     for i in selected_indices[1:]:
-      del(script_lines[i])
+        del script_lines[i]
 
     update_display()
 
-def edit_selected(event = None, selected_idx = None):
+
+def edit_selected(event=None, selected_idx=None):
     if not selected_idx:
-      selected_indices = script_listbox.curselection()
-      if not selected_indices:
-          messagebox.showinfo("No selection", "Please select item to split.")
-          return
-      
-      if len(selected_indices) > 1:
-          messagebox.showinfo("Too many selection", "Please select one item.")
-          return
-        
-      selected_idx = selected_indices[0]
+        selected_indices = script_listbox.curselection()
+        if not selected_indices:
+            messagebox.showinfo("No selection", "Please select item to split.")
+            return
+
+        if len(selected_indices) > 1:
+            messagebox.showinfo("Too many selection", "Please select one item.")
+            return
+
+        selected_idx = selected_indices[0]
 
     selected_line = script_lines[selected_idx]
-    
-    print("Edit",  selected_line)
+
+    print("Edit", selected_line)
 
     top = tk.Toplevel(root)
     top.title("Edit and Split Line")
     text = tk.Text(top, height=5, width=50)
     text.pack(padx=10, pady=10)
     text.insert(tk.END, selected_line)
-    
+
     editted_lines = []
-    def edit_and_close(event = None):
+
+    def edit_and_close(event=None):
         global splitted_lines
-        edited_line = text.get('1.0', tk.END).strip()
-        editted_lines = edited_line.split('\n')
+        edited_line = text.get("1.0", tk.END).strip()
+        editted_lines = edited_line.split("\n")
         top.destroy()
 
-        del(script_lines[selected_idx])
+        del script_lines[selected_idx]
         print(editted_lines)
         for i in reversed(editted_lines):
-          script_lines.insert(selected_idx, i)
-        
+            script_lines.insert(selected_idx, i)
+
         update_display()
 
     text.bind("<Control-Return>", edit_and_close)
     text.bind("<FocusOut>", edit_and_close)
-    text.bind("<Escape>", lambda e: top.destroy()) 
+    text.bind("<Escape>", lambda e: top.destroy())
 
     button = tk.Button(top, text="Done", command=lambda: edit_and_close())
     button.pack(pady=5)
 
 
-def remove_selected(event = None):
+def remove_selected(event=None):
     selected_indices = script_listbox.curselection()
     if not selected_indices:
         messagebox.showinfo("No selection", "Please select items to remove.")
         return
     print("Delete", selected_lines)
     for i in selected_indices[1:]:
-      del(script_lines[i])
+        del script_lines[i]
     update_display()
 
-def on_list_double_click(event):
-  index = script_listbox.nearest(event.y)
-  if not script_listbox.selection_includes(index):
-      return
-
-  text = script_listbox.get(index)
-  
-  entry = tk.Entry(root, bd=1, highlightthickness=1, )
-  entry.insert(0, text)
-  entry.select_range(0, tk.END)
-  
-  def save_edit(event=None):
-      script_listbox.delete(index)
-      script_listbox.insert(index, entry.get())
-      entry.destroy()
-  
-  bbox = script_listbox.bbox(index)
-  entry.place(x=bbox[0], y=bbox[1], width=bbox[2], height=bbox[3])
-  
-  entry.bind("<Return>", save_edit)
-  entry.bind("<FocusOut>", save_edit)
-  entry.bind("<Escape>", lambda e: entry.destroy())
-  
-  entry.focus_set()
 
 def on_list_double_click(event):
-  index = script_listbox.nearest(event.y)
-  if not script_listbox.selection_includes(index):
-      return
-  edit_selected(selected_idx = index)
+    index = script_listbox.nearest(event.y)
+    if not script_listbox.selection_includes(index):
+        return
+
+    text = script_listbox.get(index)
+
+    entry = tk.Entry(
+        root,
+        bd=1,
+        highlightthickness=1,
+    )
+    entry.insert(0, text)
+    entry.select_range(0, tk.END)
+
+    def save_edit(event=None):
+        script_listbox.delete(index)
+        script_listbox.insert(index, entry.get())
+        entry.destroy()
+
+    bbox = script_listbox.bbox(index)
+    entry.place(x=bbox[0], y=bbox[1], width=bbox[2], height=bbox[3])
+
+    entry.bind("<Return>", save_edit)
+    entry.bind("<FocusOut>", save_edit)
+    entry.bind("<Escape>", lambda e: entry.destroy())
+
+    entry.focus_set()
+
+
+def on_list_double_click(event):
+    index = script_listbox.nearest(event.y)
+    if not script_listbox.selection_includes(index):
+        return
+    edit_selected(selected_idx=index)
+
 
 def update_stdout():
     stdoutext.config(state=tk.NORMAL)
@@ -451,47 +525,68 @@ def update_stdout():
     stdoutext.config(state=tk.DISABLED)
     debugwindow.after(100, update_stdout)
 
+
 def show_console_output_screen():
-  global stdoutext, debugwindow
-  debugwindow = tk.Toplevel(root)
-  debugwindow.geometry("700x400")
-  stdoutext = tk.Text(debugwindow, state=tk.DISABLED)
-  stdoutext.pack(padx=15, pady=15, fill=tk.BOTH)
-  update_stdout()
+    global stdoutext, debugwindow
+    debugwindow = tk.Toplevel(root)
+    debugwindow.geometry("700x400")
+    stdoutext = tk.Text(debugwindow, state=tk.DISABLED)
+    stdoutext.pack(padx=15, pady=15, fill=tk.BOTH)
+    update_stdout()
+
 
 def on_prev_line():
-  load_next_line(diff=-1)
+    load_next_line(diff=-1)
+
 
 speedex = 1
 
+
 def inc_playrate():
-  global speedex
-  speedex = round(speedex * 1.2, 2)
-  playrate()
+    global speedex
+    speedex = round(speedex * 1.2, 2)
+    playrate()
+
 
 def dec_playrate():
-  global speedex
-  speedex = round(speedex / 1.2, 2)
-  playrate()
+    global speedex
+    speedex = round(speedex / 1.2, 2)
+    playrate()
+
 
 def playrate():
-  speed_label.config(text=f"x{speedex:.2f}")
-  print(f"Playback rate x{speedex:.2f}")
-  player.set_rate(speedex)
+    speed_label.config(text=f"x{speedex:.2f}")
+    print(f"Playback rate x{speedex:.2f}")
+    player.set_rate(speedex)
+
 
 root = tk.Tk()
 root.title("Subtitle Editor")
-root.geometry('1000x800')
+root.geometry("1000x800")
 root.resizable(False, False)
 
 content_frame = tk.Frame(root)
 content_frame.pack(side=tk.LEFT, padx=5, pady=5)
 
-subtitle_text = tk.Text(content_frame, width=100, height=20, borderwidth=1, relief="solid", state=tk.DISABLED)
-subtitle_text.pack(side=tk.BOTTOM, fill='both', expand=True)
+subtitle_text = tk.Text(
+    content_frame,
+    width=100,
+    height=20,
+    borderwidth=1,
+    relief="solid",
+    state=tk.DISABLED,
+)
+subtitle_text.pack(side=tk.BOTTOM, fill="both", expand=True)
 
-script_listbox = tk.Listbox(content_frame, width=100, height=20, borderwidth=1, relief="solid", selectmode=tk.EXTENDED)
-script_listbox.pack(side=tk.BOTTOM, fill='both', expand=True)
+script_listbox = tk.Listbox(
+    content_frame,
+    width=100,
+    height=20,
+    borderwidth=1,
+    relief="solid",
+    selectmode=tk.EXTENDED,
+)
+script_listbox.pack(side=tk.BOTTOM, fill="both", expand=True)
 
 context_menu = tk.Menu(root, tearoff=0)
 context_menu.add_command(label="Merge (M)", command=merge_selected)
@@ -509,15 +604,17 @@ script_listbox.bind("<Double-1>", on_list_double_click)
 
 
 button_frame = tk.Frame(root)
-button_frame.pack(side=tk.BOTTOM, pady=(0,15))
+button_frame.pack(side=tk.BOTTOM, pady=(0, 15))
 
-rewind_button = tk.Button(button_frame, text='-5s', width=2, command=rewind_audio)
+rewind_button = tk.Button(button_frame, text="-5s", width=2, command=rewind_audio)
 rewind_button.pack(side=tk.LEFT, padx=5, pady=5)
 
-play_button = tk.Button(button_frame, text='P/P',  width=2, command=toggle_audio)
+play_button = tk.Button(button_frame, text="P/P", width=2, command=toggle_audio)
 play_button.pack(side=tk.LEFT, padx=5, pady=5)
 
-fastforward_button = tk.Button(button_frame, text='+5s', width=2, command=fastforward_audio)
+fastforward_button = tk.Button(
+    button_frame, text="+5s", width=2, command=fastforward_audio
+)
 fastforward_button.pack(side=tk.LEFT, padx=5, pady=5)
 
 timestamp_label = tk.Label(root, text="0.00s / 0.00s")
@@ -527,74 +624,75 @@ timestamp_label.pack(side=tk.BOTTOM, pady=5)
 ctrl_frame = tk.Frame(root, borderwidth=0, relief="solid")
 ctrl_frame.pack(side=tk.BOTTOM, padx=5)
 
-one_button = tk.Button(ctrl_frame, text='-', borderwidth=0, command=dec_playrate)
-one_button.pack(side=tk.LEFT, padx=(5,0), pady=5)
+one_button = tk.Button(ctrl_frame, text="-", borderwidth=0, command=dec_playrate)
+one_button.pack(side=tk.LEFT, padx=(5, 0), pady=5)
 
 speed_label = tk.Label(ctrl_frame, text="x1")
 speed_label.pack(side=tk.LEFT, padx=0, pady=5)
 
-two_button = tk.Button(ctrl_frame, text='+', borderwidth=0, command=inc_playrate)
-two_button.pack(side=tk.LEFT, padx=(0,5), pady=5)
-
+two_button = tk.Button(ctrl_frame, text="+", borderwidth=0, command=inc_playrate)
+two_button.pack(side=tk.LEFT, padx=(0, 5), pady=5)
 
 
 btn_frame = tk.Frame(root, borderwidth=0, relief="solid")
 btn_frame.pack(side=tk.BOTTOM, padx=5)
 
-next_button = tk.Button(btn_frame, text='Mark', width=2, command=on_next_press)
+next_button = tk.Button(btn_frame, text="Mark", width=2, command=on_next_press)
 next_button.pack(side=tk.LEFT, padx=5, pady=5)
 
-autonext_button = tk.Button(btn_frame, text='Next', width=2, command=on_autonext_press)
+autonext_button = tk.Button(btn_frame, text="Next", width=2, command=on_autonext_press)
 autonext_button.pack(side=tk.LEFT, padx=5, pady=5)
 
-done_button = tk.Button(btn_frame, text='Done', width=2, command=on_done_press)
+done_button = tk.Button(btn_frame, text="Done", width=2, command=on_done_press)
 done_button.pack(side=tk.LEFT, padx=5, pady=5)
 
 
 btn_frame2 = tk.Frame(root, borderwidth=0, relief="solid")
 btn_frame2.pack(side=tk.BOTTOM, padx=5)
 
-prev_button = tk.Button(btn_frame2, text='Back', width=2, command=on_prev_line)
+prev_button = tk.Button(btn_frame2, text="Back", width=2, command=on_prev_line)
 prev_button.pack(side=tk.LEFT, padx=5, pady=5)
 
-del_button = tk.Button(btn_frame2, text='Del', width=2, command=on_back)
+del_button = tk.Button(btn_frame2, text="Del", width=2, command=on_back)
 del_button.pack(side=tk.LEFT, padx=5, pady=5)
 
-skip_button = tk.Button(btn_frame2, text='Skip', width=2, command=load_next_line)
+skip_button = tk.Button(btn_frame2, text="Skip", width=2, command=load_next_line)
 skip_button.pack(side=tk.LEFT, padx=5, pady=5)
 
 
 file_frame = tk.Frame(root, padx=10, pady=5, borderwidth=0, relief="solid")
-file_frame.pack(side=tk.TOP, padx=(0,5), pady=5, fill=tk.BOTH)
+file_frame.pack(side=tk.TOP, padx=(0, 5), pady=5, fill=tk.BOTH)
 
-audio_button = tk.Button(file_frame, text='Choose Audio', command=choose_audio)
+audio_button = tk.Button(file_frame, text="Choose Audio", command=choose_audio)
 audio_button.pack(side=tk.TOP, fill=tk.X)
 
-audio_label = tk.Label(file_frame, text='No audio file selected')
+audio_label = tk.Label(file_frame, text="No audio file selected")
 audio_label.pack(side=tk.TOP, pady=5)
 
-script_button = tk.Button(file_frame, text='Choose Script',  command=choose_script)
+script_button = tk.Button(file_frame, text="Choose Script", command=choose_script)
 script_button.pack(side=tk.TOP, fill=tk.X)
 
-script_label = tk.Label(file_frame, text='No script file selected')
+script_label = tk.Label(file_frame, text="No script file selected")
 script_label.pack(side=tk.TOP, pady=5)
 
-saveprog_button = tk.Button(file_frame, text='Save progress', command=save_prog)
+saveprog_button = tk.Button(file_frame, text="Save progress", command=save_prog)
 saveprog_button.pack(side=tk.TOP, pady=5, fill=tk.X)
 
-loadprog_button = tk.Button(file_frame, text='Load progress',  command=load_prog)
+loadprog_button = tk.Button(file_frame, text="Load progress", command=load_prog)
 loadprog_button.pack(side=tk.TOP, fill=tk.X)
 
-save_button = tk.Button(file_frame, text='Save Subtitles', command=save_subtitles)
+save_button = tk.Button(file_frame, text="Save Subtitles", command=save_subtitles)
 save_button.pack(side=tk.TOP, pady=5, fill=tk.X)
 
-stack_button = tk.Button(file_frame, text='Save Stacked', command=save_stacked_subtitles)
-stack_button.pack(side=tk.TOP, pady=(0,10), fill=tk.X)
+stack_button = tk.Button(
+    file_frame, text="Save Stacked", command=save_stacked_subtitles
+)
+stack_button.pack(side=tk.TOP, pady=(0, 10), fill=tk.X)
 
 skip_time_frame = tk.Frame(file_frame)
 skip_time_frame.pack(side=tk.TOP, fill=tk.X)
 
-skip_time_button = tk.Button(skip_time_frame, text='Skip To', command=skip_to_time)
+skip_time_button = tk.Button(skip_time_frame, text="Skip To", command=skip_to_time)
 skip_time_button.pack(side=tk.LEFT)
 
 skip_time_entry = tk.Entry(skip_time_frame)
@@ -602,9 +700,16 @@ skip_time_entry.pack(side=tk.LEFT, padx=5, fill=tk.X)
 skip_time_entry.insert(0, "0")
 
 info_frame = tk.Frame(root, borderwidth=0, relief="solid", width=10, height=10, padx=10)
-info_frame.pack(side=tk.TOP, expand=True, anchor="nw", padx=(5,15), pady=(10,15))
+info_frame.pack(side=tk.TOP, expand=True, anchor="nw", padx=(5, 15), pady=(10, 15))
 
-info_label = tk.Label(info_frame, text='[ Current stack ]\n', width=20, font=("monospace", 8), anchor="nw", justify=tk.LEFT)
+info_label = tk.Label(
+    info_frame,
+    text="[ Current stack ]\n",
+    width=20,
+    font=("monospace", 8),
+    anchor="nw",
+    justify=tk.LEFT,
+)
 
 # info_label = tk.Label(info_frame, text='' \
 #   # 'VTT Maker by @morgan9e\n\n' \
@@ -615,43 +720,50 @@ info_label = tk.Label(info_frame, text='[ Current stack ]\n', width=20, font=("m
 
 info_label.pack(side=tk.TOP, anchor="nw")
 
-debug_button = tk.Button(root, text='Show stdout', command=show_console_output_screen, borderwidth=0)
-debug_button.pack(side=tk.TOP, pady=(0,5))
+debug_button = tk.Button(
+    root, text="Show stdout", command=show_console_output_screen, borderwidth=0
+)
+debug_button.pack(side=tk.TOP, pady=(0, 5))
+
 
 def presskey(btn, func):
-  def wrapper(event):
-    btn.config(relief=tk.SUNKEN)
-    root.after(100, lambda: btn.config(relief=tk.RAISED))
-    return func()
-  return wrapper
+    def wrapper(event):
+        btn.config(relief=tk.SUNKEN)
+        root.after(100, lambda: btn.config(relief=tk.RAISED))
+        return func()
 
-root.bind('\'', presskey(next_button,on_next_press))
-root.bind(';', presskey(autonext_button,on_autonext_press))
-root.bind('<Return>', presskey(skip_button,on_done_press))
-root.bind('\\', on_back)
-root.bind('<space>', presskey(play_button,toggle_audio))
+    return wrapper
 
-root.bind('<Left>', presskey(rewind_button,rewind_audio))
-root.bind('<Right>', presskey(fastforward_button,fastforward_audio))
+
+root.bind("'", presskey(next_button, on_next_press))
+root.bind(";", presskey(autonext_button, on_autonext_press))
+root.bind("<Return>", presskey(skip_button, on_done_press))
+root.bind("\\", on_back)
+root.bind("<space>", presskey(play_button, toggle_audio))
+
+root.bind("<Left>", presskey(rewind_button, rewind_audio))
+root.bind("<Right>", presskey(fastforward_button, fastforward_audio))
 
 root.bind("<Button-1>", on_left_click)
 
+
 def on_closing():
     if messagebox.askokcancel("Quit", "Do you want to quit?"):
         player.stop()
         root.destroy()
 
+
 root.protocol("WM_DELETE_WINDOW", on_closing)
 
 update_timestamp()
 update_display()
 
-stdout = sys.stdout  
-stderr = sys.stderr  
+stdout = sys.stdout
+stderr = sys.stderr
 sys.stdout = TextRedirector(stdout_buf, stdout)
 sys.stderr = TextRedirector(stdout_buf, stderr)
 
 root.mainloop()
 
 sys.stdout = stdout
-sys.stderr = stderr
\ No newline at end of file
+sys.stderr = stderr
diff --git a/wordvtt.py b/wordvtt.py
index c3b2a36..475c43f 100644
--- a/wordvtt.py
+++ b/wordvtt.py
@@ -4,50 +4,64 @@ import re, json
 import os
 from datetime import timedelta
 
+
 def from_vtt(vtt_string):
-  VTT_TIMECODE_PATTERN = r"((?:\d{2}:)?\d{2}:\d{2}\.\d{3}) --> ((?:\d{2}:)?\d{2}:\d{2}\.\d{3})"
-  VTT_LINE_NUMBER_PATTERN = r"^\d+$"
-  parts = re.split(r'\n\n+', vtt_string.strip())
-  if parts[0].startswith('WEBVTT'):
-    parts.pop(0)
+    VTT_TIMECODE_PATTERN = (
+        r"((?:\d{2}:)?\d{2}:\d{2}\.\d{3}) --> ((?:\d{2}:)?\d{2}:\d{2}\.\d{3})"
+    )
+    VTT_LINE_NUMBER_PATTERN = r"^\d+$"
+    parts = re.split(r"\n\n+", vtt_string.strip())
+    if parts[0].startswith("WEBVTT"):
+        parts.pop(0)
 
-  subtitles = []
-  for part in parts:
-    lines = part.split('\n')
-    match = re.match(VTT_TIMECODE_PATTERN, lines[0])
-    if not match:
-      if re.match(VTT_LINE_NUMBER_PATTERN, lines[0]):
-        lines.pop(0)
-      match = re.match(VTT_TIMECODE_PATTERN, lines[0])
-    if not match:
-      continue
+    subtitles = []
+    for part in parts:
+        lines = part.split("\n")
+        match = re.match(VTT_TIMECODE_PATTERN, lines[0])
+        if not match:
+            if re.match(VTT_LINE_NUMBER_PATTERN, lines[0]):
+                lines.pop(0)
+            match = re.match(VTT_TIMECODE_PATTERN, lines[0])
+        if not match:
+            continue
 
-    start, end = match.groups()
-    content = '\n'.join(lines[1:]) + "\n"
-    subtitles.append({
-      'start': start,
-      'end': end,
-      'content': (content.replace("-\n", "\n").replace("</u>-\n", "</u>\n").replace("-", " ").replace("%", " ").replace("<u> "," <u>").replace(" </u>","</u> ").replace("<u> </u>","").replace("<u></u>","").replace(" \n", "\n"))[:-1]
-    })
-  # def sanitizevttwordlevel(subtitles):
-  #   errorwords = []
-  #   newords = {}
-  #   for subtitle in subtitles:
-  #     for word in subtitle["content"].split(" "):
-  #       if ("<u>" in word):
-  #         newword = None
-  #         if (len(word.split("<u>")) > 1):
-  #           newword = word.replace("<u>", " <u>")
-  #         if (len(word.split("</u>")) > 1):
-  #           newword = word.replace("</u>", "</u> ")
-  #         if newword:
-  #           original = word.split("<u>")[1].split("</u>")[0]
-  #           if original in errorwords:
-  #             for i in errorwords[original]:
+        start, end = match.groups()
+        content = "\n".join(lines[1:]) + "\n"
+        subtitles.append(
+            {
+                "start": start,
+                "end": end,
+                "content": (
+                    content.replace("-\n", "\n")
+                    .replace("</u>-\n", "</u>\n")
+                    .replace("-", " ")
+                    .replace("%", " ")
+                    .replace("<u> ", " <u>")
+                    .replace(" </u>", "</u> ")
+                    .replace("<u> </u>", "")
+                    .replace("<u></u>", "")
+                    .replace(" \n", "\n")
+                )[:-1],
+            }
+        )
+    # def sanitizevttwordlevel(subtitles):
+    #   errorwords = []
+    #   newords = {}
+    #   for subtitle in subtitles:
+    #     for word in subtitle["content"].split(" "):
+    #       if ("<u>" in word):
+    #         newword = None
+    #         if (len(word.split("<u>")) > 1):
+    #           newword = word.replace("<u>", " <u>")
+    #         if (len(word.split("</u>")) > 1):
+    #           newword = word.replace("</u>", "</u> ")
+    #         if newword:
+    #           original = word.split("<u>")[1].split("</u>")[0]
+    #           if original in errorwords:
+    #             for i in errorwords[original]:
 
-
-  #           else:
-  #             errorwords[orig].append(word)
+    #           else:
+    #             errorwords[orig].append(word)
 
     #   error = False
     #   if "<u>" in subtitle["content"]:
@@ -63,347 +77,386 @@ def from_vtt(vtt_string):
     #     for word in subtitle["content"].split(" "):
     #       if word.replace("<u>")
 
-  #   for subtitle in subtitles:
-  #     for words in subtitle["content"].split(" "):
-  #       if word in errorwords:
-  #         subtitle["content"]
+    #   for subtitle in subtitles:
+    #     for words in subtitle["content"].split(" "):
+    #       if word in errorwords:
+    #         subtitle["content"]
+
+    # sanitizevttwordlevel(subtitles)
+    return subtitles
 
-  # sanitizevttwordlevel(subtitles)
-  return subtitles
 
 def to_vtt(subtitles):
     vtt_content = "WEBVTT\n\n\n"
     for idx, subtitle in enumerate(subtitles):
-        content = subtitle['content']
+        content = subtitle["content"]
         if not subtitle.get("split", False):
-          start = subtitle['start']
-          end = subtitle['end']
-          vtt_content += f"{start} --> {end}\n{content}\n\n\n"
+            start = subtitle["start"]
+            end = subtitle["end"]
+            vtt_content += f"{start} --> {end}\n{content}\n\n\n"
         else:
-          vtt_content += f"NOTE {content}\n\n\n"
+            vtt_content += f"NOTE {content}\n\n\n"
 
     return vtt_content.strip()
 
+
 def to_stacked_vtt(subtitles):
-  vtt_content = "WEBVTT\n\n\n"
-  buffer = ""
-  for subtitle in subtitles:
-    if subtitle.get("split", False):
-      buffer = ""
-      continue
-    if len(buffer) != 0:
-      if str(subtitle['content'].strip())[-1] == ".":
-        buffer += "\n"
-      else:
-        buffer += " "
-    buffer += subtitle['content'].strip()
-    vtt_content += f"{subtitle['start']} --> {subtitle['end']}\n"
-    vtt_content += buffer
-    vtt_content += "\n\n\n"
-  return vtt_content
+    vtt_content = "WEBVTT\n\n\n"
+    buffer = ""
+    for subtitle in subtitles:
+        if subtitle.get("split", False):
+            buffer = ""
+            continue
+        if len(buffer) != 0:
+            if str(subtitle["content"].strip())[-1] == ".":
+                buffer += "\n"
+            else:
+                buffer += " "
+        buffer += subtitle["content"].strip()
+        vtt_content += f"{subtitle['start']} --> {subtitle['end']}\n"
+        vtt_content += buffer
+        vtt_content += "\n\n\n"
+    return vtt_content
+
 
 def script_from_word_vtt(wordvtt):
-  subtitles = from_vtt(wordvtt)
-  print(f"VTT {len(subtitles)} lines. Generating script file from VTT.")
-  sentences = []
-  EXCEPTION_FLAG, ADD_NEXT_SENTENCE = "", 0
-  for n, subtitle in enumerate(subtitles):
-    sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
-    if ((sentences[-1] if sentences else None) != sentence) or ADD_NEXT_SENTENCE:
-      sentences.append(sentence)
-    ADD_NEXT_SENTENCE = 0
-    if subtitle["content"][-4:] == "</u>":
-      # print(f"{len(sentences)} END {subtitle["content"]}")
-      ADD_NEXT_SENTENCE = 1
-      if n + 2 < len(subtitles):
-        if subtitles[n+2]["content"].replace("<u>", "").replace("</u>", "") != sentence:
-          ADD_NEXT_SENTENCE = 0
-  return sentences
+    subtitles = from_vtt(wordvtt)
+    print(f"VTT {len(subtitles)} lines. Generating script file from VTT.")
+    sentences = []
+    EXCEPTION_FLAG, ADD_NEXT_SENTENCE = "", 0
+    for n, subtitle in enumerate(subtitles):
+        sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
+        if ((sentences[-1] if sentences else None) != sentence) or ADD_NEXT_SENTENCE:
+            sentences.append(sentence)
+        ADD_NEXT_SENTENCE = 0
+        if subtitle["content"][-4:] == "</u>":
+            # print(f"{len(sentences)} END {subtitle["content"]}")
+            ADD_NEXT_SENTENCE = 1
+            if n + 2 < len(subtitles):
+                if (
+                    subtitles[n + 2]["content"].replace("<u>", "").replace("</u>", "")
+                    != sentence
+                ):
+                    ADD_NEXT_SENTENCE = 0
+    return sentences
+
 
 def create_word_scenes(wordvtt, scriptraw):
-  subtitles = from_vtt(wordvtt)
-  scripts   = [i for i in scriptraw.split("\n") if i]
-  print(f"VTT {len(subtitles)} lines, Script {len(scripts)} lines")
-  scenes = []
-  for n, script in enumerate(scripts):
-    if len(script.split(" ")) == 1:
-      continue
-    scenes.append({"scene": script, "timestamp": []})
+    subtitles = from_vtt(wordvtt)
+    scripts = [i for i in scriptraw.split("\n") if i]
+    print(f"VTT {len(subtitles)} lines, Script {len(scripts)} lines")
+    scenes = []
+    for n, script in enumerate(scripts):
+        if len(script.split(" ")) == 1:
+            continue
+        scenes.append({"scene": script, "timestamp": []})
 
-  scenes_cur = 0
-  for n, subtitle in enumerate(subtitles):
-    sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
-    if len(sentence.split(" ")) == 1:
-      continue
+    scenes_cur = 0
+    for n, subtitle in enumerate(subtitles):
+        sentence = subtitle["content"].replace("<u>", "").replace("</u>", "")
+        if len(sentence.split(" ")) == 1:
+            continue
 
-    if sentence != scenes[scenes_cur].get("scene"):
-      if sentence == scenes[scenes_cur+1].get("scene"):
-        scenes_cur += 1
-      else:
-        print(f"Error, Mismatch in scenes\n=>\"[{scenes_cur}] {scenes[scenes_cur].get("scene")}\" or \"[{scenes_cur+1}] {scenes[scenes_cur+1].get("scene")}\" != \"{sentence}\"")
-        return
+        if sentence != scenes[scenes_cur].get("scene"):
+            if sentence == scenes[scenes_cur + 1].get("scene"):
+                scenes_cur += 1
+            else:
+                print(
+                    f"Error, Mismatch in scenes\n=>\"[{scenes_cur}] {scenes[scenes_cur].get("scene")}\" or \"[{scenes_cur+1}] {scenes[scenes_cur+1].get("scene")}\" != \"{sentence}\""
+                )
+                return
 
-    current_scene = scenes[scenes_cur]
-    if current_scene["timestamp"]:
-      word_idx = current_scene["timestamp"][-1]["index"] + 1
-    else:
-      word_idx = 0
+        current_scene = scenes[scenes_cur]
+        if current_scene["timestamp"]:
+            word_idx = current_scene["timestamp"][-1]["index"] + 1
+        else:
+            word_idx = 0
 
-    # print(scenes_cur, subtitle, word_idx, sentence)
-    if ("<u>" not in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
-      pass
-    if ("<u>" in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
-      print(f"Error, index wrong. {scenes_cur}, word: {word_idx}, total words: {len(sentence.split(" "))}\n{subtitle}")
-      word_idx = 0
-      scenes_cur += 1
-      current_scene = scenes[scenes_cur]
-      if current_scene["timestamp"]:
-        word_idx = current_scene["timestamp"][-1]["index"] + 1
-      else:
-        word_idx = 0
-      print(f"Changed to {word_idx}, {scenes_cur}")
+        # print(scenes_cur, subtitle, word_idx, sentence)
+        if ("<u>" not in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
+            pass
+        if ("<u>" in subtitle["content"]) and word_idx >= len(sentence.split(" ")):
+            print(
+                f"Error, index wrong. {scenes_cur}, word: {word_idx}, total words: {len(sentence.split(" "))}\n{subtitle}"
+            )
+            word_idx = 0
+            scenes_cur += 1
+            current_scene = scenes[scenes_cur]
+            if current_scene["timestamp"]:
+                word_idx = current_scene["timestamp"][-1]["index"] + 1
+            else:
+                word_idx = 0
+            print(f"Changed to {word_idx}, {scenes_cur}")
 
-    if "<u>" in subtitle["content"]:
-      # print(subtitle["content"])
-      word = subtitle["content"].split("<u>")[1].split("</u>")[0]
+        if "<u>" in subtitle["content"]:
+            # print(subtitle["content"])
+            word = subtitle["content"].split("<u>")[1].split("</u>")[0]
 
-      if word not in sentence.split(" "):
-        print(f"Error, Mismatch\n=> \"{word}\" not in \"{sentence}\"")
-        return
+            if word not in sentence.split(" "):
+                print(f'Error, Mismatch\n=> "{word}" not in "{sentence}"')
+                return
 
-      try:
-        assert sentence.split(" ")[word_idx] == word
-      except:
-        print(f"Error, Mismatch\n=> \"{word}\" != [{word_idx}] of \"{sentence}\"")
-        return
+            try:
+                assert sentence.split(" ")[word_idx] == word
+            except:
+                print(f'Error, Mismatch\n=> "{word}" != [{word_idx}] of "{sentence}"')
+                return
 
-      word_time = {"start": subtitle["start"], "end": subtitle["end"], "index": word_idx, "word": word}
-      current_scene["timestamp"].append(word_time)
+            word_time = {
+                "start": subtitle["start"],
+                "end": subtitle["end"],
+                "index": word_idx,
+                "word": word,
+            }
+            current_scene["timestamp"].append(word_time)
 
-  # print(json.dumps(scenes, indent=2))
+    # print(json.dumps(scenes, indent=2))
 
-  for scene in scenes:
-    if len(scene["scene"].split(" ")) != len(scene["timestamp"]):
-      print("Error, Mismatch length")
-      return
-    if "" in scene["scene"].split(" "):
-      print(repr(scene["scene"]))
+    for scene in scenes:
+        if len(scene["scene"].split(" ")) != len(scene["timestamp"]):
+            print("Error, Mismatch length")
+            return
+        if "" in scene["scene"].split(" "):
+            print(repr(scene["scene"]))
 
-  full_script, full_scenes = [], []
-  for scene in scenes:
-    full_script += scene["scene"].split(" ")[:-1]
-    full_script.append(scene["scene"].split(" ")[-1]+"##")
-    full_scenes += scene["timestamp"]
+    full_script, full_scenes = [], []
+    for scene in scenes:
+        full_script += scene["scene"].split(" ")[:-1]
+        full_script.append(scene["scene"].split(" ")[-1] + "##")
+        full_scenes += scene["timestamp"]
 
-  for i, j in zip(full_script, full_scenes):
-    if i.replace("##", "") != j["word"]:
-      print("Error, Mismatch")
-      return
+    for i, j in zip(full_script, full_scenes):
+        if i.replace("##", "") != j["word"]:
+            print("Error, Mismatch")
+            return
+
+    assert len(full_scenes) == len(full_script)
+
+    return full_script, full_scenes
 
 
-  assert len(full_scenes) == len(full_script)
-
-  return full_script, full_scenes
-  
 # Detect long break or change in context, inserts section break into script.
 def autobreak(lines, times):
-  from datetime import timedelta
+    from datetime import timedelta
 
-  def parsetime(time_str):
-    minutes, seconds = time_str.split(':')
-    seconds, milliseconds = seconds.split('.')
-    td = timedelta(minutes=int(minutes), seconds=int(seconds), milliseconds=int(milliseconds))
-    return td
+    def parsetime(time_str):
+        minutes, seconds = time_str.split(":")
+        seconds, milliseconds = seconds.split(".")
+        td = timedelta(
+            minutes=int(minutes), seconds=int(seconds), milliseconds=int(milliseconds)
+        )
+        return td
 
-  script = []
-  long_breaks = []
-  tmark = parsetime("0:0.0")
-  for i, j in zip(lines, times):
-    tdiff = parsetime(j["start"]) - tmark
-    tmark = parsetime(j["end"])
-    if tdiff > parsetime("0:0.0"):
-      long_breaks.append(tdiff)
-      # print()
-    # print(i, end=" ")
-  # print()
+    script = []
+    long_breaks = []
+    tmark = parsetime("0:0.0")
+    for i, j in zip(lines, times):
+        tdiff = parsetime(j["start"]) - tmark
+        tmark = parsetime(j["end"])
+        if tdiff > parsetime("0:0.0"):
+            long_breaks.append(tdiff)
+            # print()
+        # print(i, end=" ")
+    # print()
 
-  mean_break = parsetime("0:0.0")
-  for i in long_breaks:
-    mean_break += i/len(long_breaks)
-  print(mean_break)
+    mean_break = parsetime("0:0.0")
+    for i in long_breaks:
+        mean_break += i / len(long_breaks)
+    print(mean_break)
 
-  script = ""
-  tmark = parsetime("0:0.0")
-  tmp = " "
+    script = ""
+    tmark = parsetime("0:0.0")
+    tmp = " "
 
-  continous_line = 0
-  for i, j in zip(lines, times):
-    tdiff = parsetime(j["start"]) - tmark
-    tmark = parsetime(j["end"])
-    if tdiff > mean_break and tmp[-1] != ".":
-      script += "\n"
+    continous_line = 0
+    for i, j in zip(lines, times):
+        tdiff = parsetime(j["start"]) - tmark
+        tmark = parsetime(j["end"])
+        if tdiff > mean_break and tmp[-1] != ".":
+            script += "\n"
 
-    if (tdiff >= mean_break and tmp[-1] == "."):
-        script += "\n"
-        continous_line = 0
-    else:
-      continous_line += 1
+        if tdiff >= mean_break and tmp[-1] == ".":
+            script += "\n"
+            continous_line = 0
+        else:
+            continous_line += 1
 
-    script += i.replace("##", "")
+        script += i.replace("##", "")
+
+        if i[-1] == ".":
+            script += "\n"
+        elif "##" in i:
+            script += "\n"
+        else:
+            script += " "
+        tmp = i
+
+    return script
 
-    if i[-1] == ".":
-      script += "\n"
-    elif "##" in i:
-        script += "\n"
-    else:
-      script += " " 
-    tmp = i
-  
-  return script
 
 def scene_from_new_script(raw_script, full_script, full_scenes):
-  mod_script = raw_script.replace("\n", " \n ").split(" ")
-  mod_script = [i for i in mod_script if i]
-  n = 0
-  while True:
-    if mod_script[n] == "\n":
-      mod_script[n-1] += "\n"
-      del(mod_script[n])
-      n -= 1
-    n += 1
-    if n == len(mod_script):
-      break
-  # print(mod_script)
-  print(f"Original: {len(full_script)}, Modded: {len(mod_script)}")
-  allowed_list = [".", "\n", "\n\n", ",", "?", "##"]
+    mod_script = raw_script.replace("\n", " \n ").split(" ")
+    mod_script = [i for i in mod_script if i]
+    n = 0
+    while True:
+        if mod_script[n] == "\n":
+            mod_script[n - 1] += "\n"
+            del mod_script[n]
+            n -= 1
+        n += 1
+        if n == len(mod_script):
+            break
+    # print(mod_script)
+    print(f"Original: {len(full_script)}, Modded: {len(mod_script)}")
+    allowed_list = [".", "\n", "\n\n", ",", "?", "##"]
+
+    def normalized(x):
+        for i in allowed_list:
+            x = x.replace(i, "")
+        return x.upper()
+
+    same = lambda a, b: normalized(a) == normalized(b)
+    new_script, new_timestamp, orig_index, n = [], [], 0, 0
+    fail = 0
+    while n < len(mod_script):
+        print(f"{repr(mod_script[n]):>20} ? {repr(full_script[orig_index])}")
+        word = mod_script[n]
+        if same(word, full_script[orig_index].replace("##", "")):
+            cur = full_scenes[orig_index]
+            new_script.append(word.replace("##", ""))
+            new_timestamp.append({"start": cur["start"], "end": cur["end"]})
+            fail = 0
+        else:
+            if fail > 10:
+                print("Error: Failed to match words,")
+                return
+            # print("Back")
+            fail += 1
+            n -= 1
+        n, orig_index = n + 1, orig_index + 1
+    assert len(new_script) == len(new_timestamp)
+    return new_script, new_timestamp
 
-  def normalized(x):
-    for i in allowed_list:
-      x = x.replace(i, "")
-    return x.upper()
-  
-  same = lambda a, b: normalized(a) == normalized(b)
-  new_script, new_timestamp, orig_index, n = [], [], 0, 0
-  fail = 0
-  while n < len(mod_script):
-    print(f"{repr(mod_script[n]):>20} ? {repr(full_script[orig_index])}")
-    word = mod_script[n]
-    if same(word, full_script[orig_index].replace("##", "")):
-      cur = full_scenes[orig_index]
-      new_script.append(word.replace("##", ""))
-      new_timestamp.append({"start": cur["start"], "end": cur["end"]})
-      fail = 0
-    else:
-      if fail > 10:
-        print("Error: Failed to match words,")
-        return
-      # print("Back")
-      fail += 1
-      n -= 1
-    n, orig_index = n+1, orig_index+1
-  assert len(new_script) == len(new_timestamp)
-  return new_script, new_timestamp
 
 def build_new_subtitle(new_script, new_timestamp):
-  buffer, new_scenes, start, end = [], [], None, None
-  current_scene = []
-  # print(" ".join(new_script).split("\n"))
+    buffer, new_scenes, start, end = [], [], None, None
+    current_scene = []
+    # print(" ".join(new_script).split("\n"))
 
-  for i, j in zip(new_script, new_timestamp):
-    if "\n" in i:
-      buffer.append(i.replace("\n", ""))
-      current_scene.append({"content": " ".join(buffer).replace("##", ""), "start": start, "end": j["end"]})
-      buffer, start = [], None
-      if "\n\n" in i:
-        print(f"Section break at line #{len(current_scene):<3}| \"{current_scene[-1]["content"]}\"")
+    for i, j in zip(new_script, new_timestamp):
+        if "\n" in i:
+            buffer.append(i.replace("\n", ""))
+            current_scene.append(
+                {
+                    "content": " ".join(buffer).replace("##", ""),
+                    "start": start,
+                    "end": j["end"],
+                }
+            )
+            buffer, start = [], None
+            if "\n\n" in i:
+                print(
+                    f"Section break at line #{len(current_scene):<3}| \"{current_scene[-1]["content"]}\""
+                )
+                new_scenes.append(current_scene)
+                current_scene = []
+        else:
+            buffer.append(i)
+            if not start:
+                start = j["start"]
+
+    if start:
+        buffer.append(i.replace("\n", ""))
+        current_scene.append(
+            {"content": " ".join(buffer), "start": start, "end": j["end"]}
+        )
+
+    if current_scene != (new_scenes[-1] if new_scenes else None):
         new_scenes.append(current_scene)
-        current_scene = []
-    else:
-      buffer.append(i)
-      if not start:
-        start = j["start"]
 
-  if start:
-      buffer.append(i.replace("\n", ""))
-      current_scene.append({"content": " ".join(buffer), "start": start, "end": j["end"]})
+    # print("\n\n".join(["\n".join([j["content"] for j in i]) for i in new_scenes]))
+    newsub = []
+    for n, i in enumerate(new_scenes):
+        newsub += i
+        if n < len(new_scenes) - 1:
+            newsub.append(
+                {"content": "Break", "start": None, "end": None, "split": True}
+            )
 
-  if current_scene != (new_scenes[-1] if new_scenes else None):
-    new_scenes.append(current_scene)
+    return newsub
 
-  # print("\n\n".join(["\n".join([j["content"] for j in i]) for i in new_scenes]))
-  newsub = []
-  for n, i in enumerate(new_scenes):
-    newsub += i
-    if n < len(new_scenes) - 1:
-      newsub.append({"content": "Break", "start": None, "end": None, "split": True})
 
-  return newsub
+def saveFile(filename, data, override=False):
+    if os.path.exists(filename) and not override:
+        print(f"File {filename} already exists.")
+        return -1
+    with open(filename, "w") as f:
+        f.write(data)
 
-def saveFile(filename, data, override = False):
-  if os.path.exists(filename) and not override:
-    print(f"File {filename} already exists.")
-    return -1
-  with open(filename, "w") as f:
-    f.write(data)
 
 def openFile(filename):
-  with open(filename, "r") as f:
-    data = f.read()
-  if not data:
-    return -1
-  return data
+    with open(filename, "r") as f:
+        data = f.read()
+    if not data:
+        return -1
+    return data
+
 
 def main(vttfile, scriptfile):
-  modfile = ".".join(scriptfile.split(".")[:-1]) + ".script"
-  x = create_word_scenes(openFile(vttfile), openFile(scriptfile))
-  if not x:
-    sys.exit(-1)
-  full_script, full_scenes = x
-
-  if not os.path.exists(modfile):
-    genscript = autobreak(full_script,full_scenes)
-    saveFile(modfile, genscript)
-    print(f"Saved modification file as {modfile}. Modify it and return back.")
-  else:
-    x = scene_from_new_script(openFile(modfile), full_script, full_scenes)
+    modfile = ".".join(scriptfile.split(".")[:-1]) + ".script"
+    x = create_word_scenes(openFile(vttfile), openFile(scriptfile))
     if not x:
-      sys.exit(-1)
-    a, b = x
+        sys.exit(-1)
+    full_script, full_scenes = x
 
-    final_vtt = build_new_subtitle(a, b)
-    jsonfile = ".".join(vttfile.split(".")[:-1]) + ".json"
-    saveFile(jsonfile, json.dumps(final_vtt, indent=2), True)
-    print(f"Saved JSON file as {jsonfile}. Fix it, and convert it to VTT.")
+    if not os.path.exists(modfile):
+        genscript = autobreak(full_script, full_scenes)
+        saveFile(modfile, genscript)
+        print(f"Saved modification file as {modfile}. Modify it and return back.")
+    else:
+        x = scene_from_new_script(openFile(modfile), full_script, full_scenes)
+        if not x:
+            sys.exit(-1)
+        a, b = x
 
-if __name__=="__main__":
-  import sys
-  if len(sys.argv) not in (2, 3):
-    print(f"Usage: {sys.argv[0].split("/")[-1]} [vtt file] (txt file)\n"                                  \
-     f"       {sys.argv[0].split("/")[-1]} [JSON file]\n"                                                 \
-      "** Only output from openai-whisper with '--word-timestamp true' is accepted.)\n"                   \
-      "** You have to run this for first time, and then fix .script file, and then re-run this script.\n" \
-      "** Adding newline/period/commas are onlt permitted. Fix else in JSON file.")
-    sys.exit()
+        final_vtt = build_new_subtitle(a, b)
+        jsonfile = ".".join(vttfile.split(".")[:-1]) + ".json"
+        saveFile(jsonfile, json.dumps(final_vtt, indent=2), True)
+        print(f"Saved JSON file as {jsonfile}. Fix it, and convert it to VTT.")
 
-  vtt = sys.argv[1]
-  print(f"\n[{vtt}]")
-  if len(sys.argv) == 3:
-    script = sys.argv[2]
-    if (not os.path.exists(vtt)) or (not os.path.exists(script)):
-      print(f"Input file doesnt exists.")
-      sys.exit(-1)
-    main(vtt, script)
-  else:
-    if ".json" in vtt:
-      final_vtt = json.loads(openFile(vtt))
-      orgf = ".".join(vtt.split(".")[:-1])
-      print(f"Saved VTT file as {orgf}.final.vtt.")
-      saveFile(orgf + ".final.vtt", to_vtt(final_vtt), True)
-      saveFile(orgf + ".stacked.vtt", to_stacked_vtt(final_vtt), True)
-      sys.exit(0)
-    if (not os.path.exists(vtt)):
-      print(f"Input file doesnt exists.")
-      sys.exit(-1)
-    script = ".".join(vtt.split(".")[:-1]) + ".txt"
-    saveFile(script, "\n".join(script_from_word_vtt(openFile(vtt))))
-    main(vtt, script)
\ No newline at end of file
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) not in (2, 3):
+        print(
+            f"Usage: {sys.argv[0].split("/")[-1]} [vtt file] (txt file)\n"
+            f"       {sys.argv[0].split("/")[-1]} [JSON file]\n"
+            "** Only output from openai-whisper with '--word-timestamp true' is accepted.)\n"
+            "** You have to run this for first time, and then fix .script file, and then re-run this script.\n"
+            "** Adding newline/period/commas are onlt permitted. Fix else in JSON file."
+        )
+        sys.exit()
+
+    vtt = sys.argv[1]
+    print(f"\n[{vtt}]")
+    if len(sys.argv) == 3:
+        script = sys.argv[2]
+        if (not os.path.exists(vtt)) or (not os.path.exists(script)):
+            print(f"Input file doesnt exists.")
+            sys.exit(-1)
+        main(vtt, script)
+    else:
+        if ".json" in vtt:
+            final_vtt = json.loads(openFile(vtt))
+            orgf = ".".join(vtt.split(".")[:-1])
+            print(f"Saved VTT file as {orgf}.final.vtt.")
+            saveFile(orgf + ".final.vtt", to_vtt(final_vtt), True)
+            saveFile(orgf + ".stacked.vtt", to_stacked_vtt(final_vtt), True)
+            sys.exit(0)
+        if not os.path.exists(vtt):
+            print(f"Input file doesnt exists.")
+            sys.exit(-1)
+        script = ".".join(vtt.split(".")[:-1]) + ".txt"
+        saveFile(script, "\n".join(script_from_word_vtt(openFile(vtt))))
+        main(vtt, script)