diff --git a/gamelog/src/game.rs b/gamelog/src/game.rs
index 175d369..ab04559 100644
--- a/gamelog/src/game.rs
+++ b/gamelog/src/game.rs
@@ -96,36 +96,36 @@ impl Game {
     }
 
     /// The average number of plays in a quarter.
-    pub fn avg_plays_per_quarter(&self, team: Team) -> f32 {
+    pub fn avg_plays_per_quarter(&self, team: Team) -> f64 {
         let periods: Vec<Period> = Quarter::iter()
             .filter_map(|quarter| self.get_period(quarter.to_owned()))
             .to_owned()
             .collect();
 
-        let quarterly_avgs: Vec<f32> = periods
+        let quarterly_avgs: Vec<f64> = periods
             .iter()
             .filter_map(|period| {
                 if !period.is_overtime() {
-                    Some(period.team_plays(team.to_owned()) as f32)
+                    Some(period.team_plays(team.to_owned()) as f64)
                 } else {
                     None
                 }
             })
-            .collect::<Vec<f32>>();
+            .collect::<Vec<f64>>();
 
-        quarterly_avgs.iter().sum::<f32>() / quarterly_avgs.len() as f32
+        quarterly_avgs.iter().sum::<f64>() / quarterly_avgs.len() as f64
     }
 
     /// Returns the average delta of a team.
-    pub fn avg_delta(&self, team: Team) -> f32 {
+    pub fn avg_delta(&self, team: Team) -> f64 {
         let deltas = self.deltas(team);
 
-        // Summation doesn't like directly returning f32 from i8.
-        deltas.iter().sum::<i8>() as f32 / deltas.len() as f32
+        // Summation doesn't like directly returning f64 from i8.
+        deltas.iter().sum::<i8>() as f64 / deltas.len() as f64
     }
 
     /// Returns the average delta for a team's positive deltas.
-    pub fn avg_gain(&self, team: Team) -> f32 {
+    pub fn avg_gain(&self, team: Team) -> f64 {
         let deltas: Vec<u8> = self
             .deltas(team)
             .iter()
@@ -138,12 +138,12 @@ impl Game {
             })
             .collect();
 
-        // Summation doesn't like directly returning f32 from u8.
-        deltas.iter().sum::<u8>() as f32 / deltas.len() as f32
+        // Summation doesn't like directly returning f64 from u8.
+        deltas.iter().sum::<u8>() as f64 / deltas.len() as f64
     }
 
     /// Returns the average delta for a team's negative deltas.
-    pub fn avg_loss(&self, team: Team) -> f32 {
+    pub fn avg_loss(&self, team: Team) -> f64 {
         let deltas: Vec<i8> = self
             .deltas(team)
             .iter()
@@ -156,7 +156,7 @@ impl Game {
             })
             .collect();
 
-        deltas.iter().sum::<i8>() as f32 / deltas.len() as f32
+        deltas.iter().sum::<i8>() as f64 / deltas.len() as f64
     }
 
     /// Returns the number of penalties that a team experienced.
@@ -381,8 +381,8 @@ mod tests {
         dbg!(a.avg_plays_per_quarter(Team::Nebraska));
         dbg!(b.avg_plays_per_quarter(Team::Nebraska));
 
-        assert!(a.avg_plays_per_quarter(Team::Nebraska) == ((1_f32 + 6_f32) / 2_f32));
-        assert!(b.avg_plays_per_quarter(Team::Nebraska) == 1_f32)
+        assert!(a.avg_plays_per_quarter(Team::Nebraska) == ((1_f64 + 6_f64) / 2_f64));
+        assert!(b.avg_plays_per_quarter(Team::Nebraska) == 1_f64)
     }
 
     #[test]
diff --git a/miller/src/main.rs b/miller/src/main.rs
index 9715156..183f4f5 100644
--- a/miller/src/main.rs
+++ b/miller/src/main.rs
@@ -4,7 +4,7 @@ use clap::{ArgAction, Parser};
 use core::panic;
 use gamelog::{Action, Down, Flags, Key, LogFile, Team, TerrainState};
 use std::{io, path::PathBuf, sync::mpsc, thread};
-use strum::IntoEnumIterator;
+//use strum::IntoEnumIterator;
 use tui::App;
 
 #[derive(Debug, Parser)]
@@ -43,9 +43,9 @@ fn main() -> io::Result<()> {
             TeamStats::new(Team::Colorado),
             TeamStats::new(Team::Iowa),
             TeamStats::new(Team::Nebraska),
-            TeamStats::new(Team::Syracuse),
             #[allow(deprecated)]
             TeamStats::new(Team::SouthCarolina),
+            TeamStats::new(Team::Syracuse),
             TeamStats::new(Team::TexasAnM),
         ];
 
@@ -89,6 +89,7 @@ fn main() -> io::Result<()> {
                     .push(game.penalties(team.to_owned()));
             }
 
+            /*
             for team in gamelog::Team::iter() {
                 let team_idx = stats
                     .iter()
@@ -98,12 +99,13 @@ fn main() -> io::Result<()> {
                 stats[team_idx].most_common_play = Some(log.most_frequent_action(team.to_owned()));
                 stats[team_idx].least_common_play =
                     Some(log.least_frequent_action(team.to_owned()));
-                /*
-                stats[team_idx].most_effective_play =
-                    Some(log.most_effective_play(team.to_owned()));
-                */
-                stats[team_idx].play_frequencies = Some(log.frequency_of_plays(team.to_owned()))
+
+                //stats[team_idx].most_effective_play =
+                //    Some(log.most_effective_play(team.to_owned()));
+
+                //stats[team_idx].play_frequencies = Some(log.frequency_of_plays(team.to_owned()))
             }
+            */
         }
 
         // :#? for pretty-printing.
@@ -134,11 +136,11 @@ fn main() -> io::Result<()> {
 struct TeamStats {
     team: gamelog::Team,
     // Terrain
-    avg_terrain_gain: Vec<f32>,
-    avg_terrain_loss: Vec<f32>,
-    avg_terrain_delta: Vec<f32>,
+    avg_terrain_gain: Vec<f64>,
+    avg_terrain_loss: Vec<f64>,
+    avg_terrain_delta: Vec<f64>,
     // Play rate
-    plays_per_quarter: Vec<f32>,
+    plays_per_quarter: Vec<f64>,
     plays_per_game: Vec<usize>,
     // Penalties
     penalties_per_game: Vec<usize>,