diff --git a/__main__.py b/__main__.py
index 2eb284c..d2c48b6 100644
--- a/__main__.py
+++ b/__main__.py
@@ -71,7 +71,7 @@ def main():
     #     list(EOLROrientation), EOLR_PERMUTATIONS
     # )
     eolrb_states, n_states = eolrb_states_generator(
-        [EOLROrientation.OneOne], EOLR_PERMUTATIONS
+        [EOLROrientation.OneOne, EOLROrientation.FourZero], EOLR_PERMUTATIONS
     )
     for i, (eolrb_cube, ori, perm, pre_auf) in enumerate(eolrb_states):
         print(
diff --git a/alg_trainer.py b/alg_trainer.py
index f06efb9..f813b33 100644
--- a/alg_trainer.py
+++ b/alg_trainer.py
@@ -15,8 +15,6 @@ def main():
             continue
         if case.startswith("Solved"):
             continue
-        if not case.startswith("OneOne"):
-            continue
         print(f'{case}: "{scramble['alg']}"')
         covered_cases.add(scramble["raw_alg"])
 
diff --git a/cube.py b/cube.py
index 079a8dd..a12a3dd 100644
--- a/cube.py
+++ b/cube.py
@@ -211,9 +211,6 @@ def condense_algorithm(moves: List[str]) -> List[str]:
         return result
 
     reduced_moves = apply_reduction(moves)
-    # print(reduced_moves)
     counted_moves = reduce_moves(reduced_moves)
-    # print(counted_moves)
     reduced_alg = build_reduced_alg(counted_moves)
-    # print(reduced_alg)
     return reduced_alg
diff --git a/scorer.py b/scorer.py
index 8155a7c..7469b34 100644
--- a/scorer.py
+++ b/scorer.py
@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Set, Tuple
 import yaml
 import dacite
 from dataclasses import dataclass
@@ -52,23 +52,61 @@ class Definitions:
     finger_regrips: List[Regrip]
 
 
+def build_missing_regrips(
+    finger_regrips: Dict[Tuple[str, str], Regrip], finger: Finger, grips: Set[str]
+) -> Dict[Tuple[str, str], Regrip]:
+    # this might just be the worst piece of code I have ever written
+    # fill in missing regrips so every pair of grips has a regrip
+    for grip_start in grips:
+        for grip_end in grips:
+            if grip_start != grip_end:
+                if (grip_start, grip_end) not in finger_regrips:
+                    # TODO: this only works for regrips which are 2 apart
+                    possible_start_regrips = {
+                        grips: regrip
+                        for grips, regrip in finger_regrips.items()
+                        if grip_start == regrip.start
+                    }
+                    possible_end_regrips = {
+                        grips: regrip
+                        for grips, regrip in finger_regrips.items()
+                        if grip_end == regrip.end
+                    }
+                    for start_regrip in possible_start_regrips.values():
+                        for end_regrip in possible_end_regrips.values():
+                            # if start grips ends at the beginning of end grip
+                            if start_regrip.end == end_regrip.start:
+                                finger_regrips[(start_regrip.start, end_regrip.end)] = (
+                                    Regrip(
+                                        finger=finger.name,
+                                        start=start_regrip.start,
+                                        end=end_regrip.end,
+                                        score=start_regrip.score + end_regrip.score,
+                                    )
+                                )
+    return finger_regrips
+
+
 def build_regrips_from_fingers(fingers: List[Finger]) -> List[Regrip]:
     regrips = []
     for finger in fingers:
         finger_regrips = {}
         for grip_set in finger.grips.values():
             # reate a dict with distances of every two elements in a list
-            for i in range(len(grip_set)):
-                for j in range(len(grip_set)):
-                    if i != j:
-                        finger_regrips[(grip_set[i], grip_set[j])] = Regrip(
-                            start=grip_set[i],
-                            end=grip_set[j],
+            for i, grip_start in enumerate(grip_set):
+                for j, grip_end in enumerate(grip_set):
+                    if grip_start != grip_end:
+                        finger_regrips[(grip_start, grip_end)] = Regrip(
+                            start=grip_start,
+                            end=grip_end,
                             score=abs(j - i) * finger.default_score,
                             finger=finger.name,
                         )
         for regrip in finger.regrips:
             finger_regrips[(regrip.start, regrip.end)] = regrip
+
+        grips = {grip for grip_set in finger.grips.values() for grip in grip_set}
+        finger_regrips = build_missing_regrips(finger_regrips, finger, grips)
         regrips.extend(finger_regrips.values())
 
     return regrips
@@ -182,7 +220,7 @@ def generate_finger_tricks(
 
     # TODO: think about this
     # don't count the first regrip
-    alg[0].finger_trick.score = 0
+    # alg[0].finger_trick.score = 0
     return alg
 
 
@@ -193,7 +231,11 @@ def build_pretty_string_from_finger_tricks_with_regrips(
 
     for finger_trick_with_regrips in finger_tricks_with_regrips:
         for regrip in finger_trick_with_regrips.regrips:
-            elems.append(f"regrip {regrip.finger} from {regrip.start} to {regrip.end}")
-        elems.append(finger_trick_with_regrips.finger_trick.name)
+            elems.append(
+                f"regrip {regrip.finger} from {regrip.start} to {regrip.end} ({regrip.score})"
+            )
+        elems.append(
+            f"{finger_trick_with_regrips.finger_trick.name} ({finger_trick_with_regrips.finger_trick.score})"
+        )
 
     return elems