diff --git a/src/run/parser/flitter.rs b/src/run/parser/flitter.rs
new file mode 100644
index 00000000..d9af8f10
--- /dev/null
+++ b/src/run/parser/flitter.rs
@@ -0,0 +1,134 @@
+//! Provides the parser for Flitter splits files.
+
+use crate::{
+    platform::prelude::*,
+    timing::{parse_custom, CustomParser},
+    Run, Segment, Time,
+};
+use alloc::borrow::Cow;
+use core::result::Result as StdResult;
+use serde_derive::Deserialize;
+use serde_json::Error as JsonError;
+use snafu::ensure;
+
+/// The Error type for splits files that couldn't be parsed by the Flitter
+/// Parser.
+#[derive(Debug, snafu::Snafu)]
+#[snafu(context(suffix(false)))]
+pub enum Error {
+    /// Failed to parse JSON.
+    Json {
+        /// The underlying error.
+        #[cfg_attr(not(feature = "std"), snafu(source(false)))]
+        source: JsonError,
+    },
+    /// The split names can't be empty.
+    SplitNamesEmpty,
+    /// The personal best can't be empty.
+    PersonalBestEmpty,
+    /// The golds can't be empty.
+    GoldsEmpty,
+    /// The split name count does not match the gold count.
+    GoldCountMismatch,
+    /// The split name count does not match the personal best split count.
+    PersonalBestCountMismatch,
+    /// The last split of the personal best can't be null.
+    LastSplitNull,
+}
+
+/// The Result type for the Flitter Parser.
+pub type Result<T> = StdResult<T, Error>;
+
+#[derive(Deserialize)]
+struct Splits<'a> {
+    #[serde(borrow)]
+    title: Cow<'a, str>,
+    #[serde(borrow)]
+    category: Cow<'a, str>,
+    attempts: u32,
+    // completed: u32,
+    #[serde(borrow)]
+    split_names: Vec<Cow<'a, str>>,
+    #[serde(borrow)]
+    golds: Vec<Option<Gold<'a>>>,
+    #[serde(borrow)]
+    personal_best: PersonalBest<'a>,
+}
+
+#[derive(Deserialize)]
+struct Gold<'a> {
+    #[serde(borrow)]
+    duration: Cow<'a, str>,
+}
+
+#[derive(Deserialize)]
+struct PersonalBest<'a> {
+    // attempt: u32,
+    #[serde(borrow)]
+    splits: Vec<Option<Split<'a>>>,
+}
+
+#[derive(Deserialize)]
+struct Split<'a> {
+    #[serde(borrow)]
+    time: Cow<'a, str>,
+}
+
+struct FlitterParser;
+
+impl CustomParser for FlitterParser {
+    const ASCII_ONLY: bool = true;
+    const ALLOW_NEGATIVE: bool = false;
+    const WITH_DAYS: bool = true;
+}
+
+fn parse_time(real_time: &str) -> Option<Time> {
+    let time = parse_custom::<FlitterParser>(real_time).ok()?;
+    Some(Time::new().with_real_time(Some(time)))
+}
+
+/// Attempts to parse an Flitter splits file.
+pub fn parse(source: &str) -> Result<Run> {
+    let splits: Splits<'_> =
+        serde_json::from_str(source).map_err(|source| Error::Json { source })?;
+
+    ensure!(!splits.split_names.is_empty(), SplitNamesEmpty);
+    ensure!(!splits.golds.is_empty(), GoldsEmpty);
+    ensure!(!splits.personal_best.splits.is_empty(), PersonalBestEmpty);
+    ensure!(
+        splits.golds.len() == splits.split_names.len(),
+        GoldCountMismatch
+    );
+    ensure!(
+        splits.personal_best.splits.len() == splits.split_names.len(),
+        PersonalBestCountMismatch
+    );
+    ensure!(
+        splits.personal_best.splits.last().unwrap().is_some(),
+        LastSplitNull
+    );
+
+    let mut run = Run::new();
+
+    run.set_game_name(splits.title);
+    run.set_category_name(splits.category);
+    run.set_attempt_count(splits.attempts);
+
+    let segments = run.segments_mut();
+
+    segments.extend(splits.split_names.into_iter().map(Segment::new));
+
+    for (segment, pb) in segments.iter_mut().zip(splits.personal_best.splits) {
+        catch! {
+            segment.set_personal_best_split_time(parse_time(&pb?.time)?);
+        };
+    }
+
+    for (segment, gold) in segments.iter_mut().zip(splits.golds) {
+        catch! {
+            segment.set_best_segment_time(parse_time(&gold?.duration)?);
+        };
+    }
+
+    Ok(run)
+}
diff --git a/src/run/parser/flitter/mod.rs b/src/run/parser/flitter/mod.rs
deleted file mode 100644
index e2eaf0a9..00000000
--- a/src/run/parser/flitter/mod.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-//! Provides the parser for Flitter splits files.
-
-use crate::{comparison::world_record, platform::prelude::*, Run, Segment, Time, TimeSpan};
-use core::result::Result as StdResult;
-use serde_derive::Deserialize;
-
-mod s_expressions;
-
-pub use self::s_expressions::Error;
-
-/// The Result type for the Flitter Parser.
-pub type Result<T> = StdResult<T, Error>;
-
-#[derive(Deserialize)]
-struct Splits<'a> {
-    title: &'a str,
-    category: &'a str,
-    attempts: u32,
-    #[serde(borrow)]
-    split_names: Vec<&'a str>,
-    golds: Option<Vec<Gold>>,
-    personal_best: Option<Comparison>,
-    world_record: Option<Comparison>,
-}
-
-#[derive(Deserialize)]
-struct Gold {
-    duration: Option<TimeSpan>,
-}
-
-#[derive(Deserialize)]
-struct Comparison {
-    splits: Vec<Split>,
-}
-
-#[derive(Deserialize)]
-struct Split {
-    time: Option<TimeSpan>,
-}
-
-/// Attempts to parse a Flitter splits file.
-pub fn parse(source: &str) -> Result<Run> {
-    let splits: Splits<'_> = self::s_expressions::from_str(source)?;
-
-    let mut run = Run::new();
-
-    run.set_game_name(splits.title);
-    run.set_category_name(splits.category);
-    run.set_attempt_count(splits.attempts);
-
-    if splits.world_record.is_some() {
-        run.add_custom_comparison(world_record::NAME).unwrap();
-    }
-
-    let segments = run.segments_mut();
-
-    segments.extend(splits.split_names.into_iter().map(Segment::new));
-
-    if let Some(pb) = splits.personal_best {
-        for (segment, pb) in segments.iter_mut().zip(pb.splits) {
-            segment.set_personal_best_split_time(Time::new().with_real_time(pb.time));
-        }
-    }
-
-    if let Some(golds) = splits.golds {
-        for (segment, gold) in segments.iter_mut().zip(golds) {
-            segment.set_best_segment_time(Time::new().with_real_time(gold.duration));
-        }
-    }
-
-    if let Some(wr) = splits.world_record {
-        for (segment, wr) in segments.iter_mut().zip(wr.splits) {
-            segment.comparison_mut(world_record::NAME).real_time = wr.time;
-        }
-    }
-
-    Ok(run)
-}
diff --git a/src/run/parser/flitter/s_expressions.rs b/src/run/parser/flitter/s_expressions.rs
deleted file mode 100644
index 8d6be9f3..00000000
--- a/src/run/parser/flitter/s_expressions.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-//! Implements a serde deserializer for S-Expressions.
-//! <http://people.csail.mit.edu/rivest/Sexp.txt>
-
-use crate::platform::prelude::*;
-use core::{fmt::Display, num::ParseIntError};
-use serde::{
-    de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor},
-    Deserialize,
-};
-
-/// The Error types for splits files that couldn't be parsed by the Flitter
-/// Parser.
-#[derive(Debug, snafu::Snafu)]
-pub enum Error {
-    /// Trailing Characters
-    TrailingCharacters,
-    /// Unexpected end of input
-    Eof,
-    /// Expected an opening parenthesis.
-    ExpectedOpeningParenthesis,
-    /// Expected an closing parenthesis.
-    ExpectedClosingParenthesis,
-    /// Expected a string.
-    ExpectedString,
-    /// Failed to parse an integer.
-    ParseInt {
-        /// The underlying error.
-        source: ParseIntError,
-    },
-    /// Encountered invalid UTF-8 sequence.
-    InvalidUtf8,
-    /// Custom error.
-    #[snafu(display("{error}"))]
-    Custom {
-        /// The underlying error.
-        error: String,
-    },
-}
-
-impl From<ParseIntError> for Error {
-    fn from(source: ParseIntError) -> Self {
-        Self::ParseInt { source }
-    }
-}
-
-impl de::Error for Error {
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        Error::Custom {
-            error: msg.to_string(),
-        }
-    }
-}
-
-pub type Result<T> = core::result::Result<T, Error>;
-
-pub struct Deserializer<'source> {
-    source: &'source str,
-}
-
-impl<'source> Deserializer<'source> {
-    pub const fn from_str(source: &'source str) -> Self {
-        Deserializer { source }
-    }
-
-    fn skip_whitespace(&mut self) {
-        self.source = self.source.trim_start();
-    }
-
-    fn starts_with(&self, c: char) -> bool {
-        self.source.starts_with(c)
-    }
-
-    fn strip_char(&mut self, c: char) -> bool {
-        match self.source.strip_prefix(c) {
-            Some(rem) => {
-                self.source = rem;
-                true
-            }
-            None => false,
-        }
-    }
-
-    fn parse_ident(&mut self) -> &'source str {
-        if let Some((pos, _)) = self
-            .source
-            .char_indices()
-            .find(|&(_, c)| c.is_whitespace() || c == ')')
-        {
-            let (before, after) = &self.source.split_at(pos);
-            self.source = after;
-            before
-        } else {
-            self.source
-        }
-    }
-
-    fn parse_string(&mut self) -> Result<&'source str> {
-        if let Some(rem) = self.source.strip_prefix('"') {
-            if let Some((in_str, after)) = rem.split_once('"') {
-                self.source = after;
-                Ok(in_str)
-            } else {
-                Err(Error::Eof)
-            }
-        } else {
-            Ok(self.parse_ident())
-        }
-    }
-
-    fn skip_to_matching_closing(&mut self) -> Result<()> {
-        let mut count = 0;
-        let mut in_string = false;
-        if let Some((pos, _)) = self.source.char_indices().find(|&(_, c)| {
-            if c == '(' {
-                if !in_string {
-                    count += 1;
-                }
-            } else if c == ')' {
-                if !in_string {
-                    if count == 0 {
-                        return true;
-                    } else {
-                        count -= 1;
-                    }
-                }
-            } else if c == '"' {
-                in_string = !in_string;
-            }
-            false
-        }) {
-            self.source = &self.source[pos..];
-            Ok(())
-        } else {
-            self.source = "";
-            Err(Error::Eof)
-        }
-    }
-}
-
-pub fn from_str<'de, T>(source: &'de str) -> Result<T>
-where
-    T: 'de + Deserialize<'de>,
-{
-    let mut deserializer = Deserializer::from_str(source);
-    let t = T::deserialize(&mut deserializer)?;
-    deserializer.skip_whitespace();
-    if deserializer.source.is_empty() {
-        Ok(t)
-    } else {
-        Err(Error::TrailingCharacters)
-    }
-}
-
-impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i64<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_u32(self.parse_ident().parse()?)
-    }
-    fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.parse_string()?)
-    }
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.parse_string()?)
-    }
-    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_some(self)
-    }
-    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.skip_whitespace();
-        if self.strip_char('(') {
-            let value = visitor.visit_seq(&mut self)?;
-            if self.strip_char(')') {
-                Ok(value)
-            } else {
-                Err(Error::ExpectedClosingParenthesis)
-            }
-        } else {
-            Err(Error::ExpectedOpeningParenthesis)
-        }
-    }
-    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        _visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.skip_whitespace();
-        if self.strip_char('(') {
-            let value = visitor.visit_map(&mut self)?;
-            if self.strip_char(')') {
-                Ok(value)
-            } else {
-                Err(Error::ExpectedClosingParenthesis)
-            }
-        } else {
-            Err(Error::ExpectedOpeningParenthesis)
-        }
-    }
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_map(visitor)
-    }
-    fn deserialize_enum<V>(
-        self,
-        _name: &'static str,
-        _variants: &'static [&'static str],
-        _visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.parse_ident())
-    }
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.skip_to_matching_closing()?;
-        visitor.visit_unit()
-    }
-}
-
-impl<'de> SeqAccess<'de> for &mut Deserializer<'de> {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        self.skip_whitespace();
-        if self.starts_with(')') {
-            Ok(None)
-        } else {
-            seed.deserialize(&mut **self).map(Some)
-        }
-    }
-}
-
-impl<'de> MapAccess<'de> for &mut Deserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-    where
-        K: DeserializeSeed<'de>,
-    {
-        self.skip_whitespace();
-        if self.starts_with(')') {
-            Ok(None)
-        } else if self.strip_char('(') {
-            self.skip_whitespace();
-            seed.deserialize(&mut **self).map(Some)
-        } else {
-            Err(Error::ExpectedOpeningParenthesis)
-        }
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        self.skip_whitespace();
-        let result = seed.deserialize(&mut **self)?;
-        self.skip_whitespace();
-        if self.strip_char(')') {
-            Ok(result)
-        } else {
-            Err(Error::ExpectedClosingParenthesis)
-        }
-    }
-}
diff --git a/src/settings/layout_background.rs b/src/settings/layout_background.rs
index e23918d4..f495ca9f 100644
--- a/src/settings/layout_background.rs
+++ b/src/settings/layout_background.rs
@@ -32,7 +32,7 @@ pub struct BackgroundImage<I> {
     /// to a reasonable value. The resulting value is the sigma (standard
     /// deviation) of the gaussian blur.
     ///
-    /// ```ignore
+    /// ```text
     /// sigma = BLUR_FACTOR * blur * max(width, height)
     /// ```
     pub blur: f32,
diff --git a/src/timing/mod.rs b/src/timing/mod.rs
index ec854313..85baab7c 100644
--- a/src/timing/mod.rs
+++ b/src/timing/mod.rs
@@ -21,3 +21,5 @@ pub use self::{
     timer_phase::TimerPhase,
     timing_method::TimingMethod,
 };
+
+pub(crate) use self::time_span::{parse_custom, CustomParser};
diff --git a/src/timing/time_span.rs b/src/timing/time_span.rs
index 93622253..1ca9043d 100644
--- a/src/timing/time_span.rs
+++ b/src/timing/time_span.rs
@@ -7,7 +7,7 @@ use core::{
     ops::{Add, AddAssign, Neg, Sub, SubAssign},
     str::FromStr,
 };
-use snafu::{ensure, OptionExt, ResultExt};
+use snafu::{OptionExt, ResultExt};
 
 /// A `TimeSpan` represents a certain span of time.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -67,11 +67,13 @@ impl TimeSpan {
 }
 
 /// The Error type for a `TimeSpan` that couldn't be parsed.
-#[derive(Debug, snafu::Snafu)]
+#[derive(Debug, snafu::Snafu, PartialEq, Eq)]
 #[snafu(context(suffix(false)))]
 pub enum ParseError {
-    /// An empty string is not a valid `TimeSpan`.
-    Empty,
+    /// There are too many colons in the string.
+    TooManyColons,
+    /// A piece separate by a colon is too large.
+    PieceOverflow,
     /// The time is too large to be represented.
     Overflow,
     /// The fractional part contains characters that are not digits.
@@ -82,63 +84,115 @@ pub enum ParseError {
         source: ParseIntError,
     },
     /// Couldn't parse the seconds, minutes, or hours.
-    Time {
+    Piece {
         /// The underlying error.
         source: ParseIntError,
     },
 }
 
-impl FromStr for TimeSpan {
-    type Err = ParseError;
+pub(crate) trait CustomParser {
+    const ASCII_ONLY: bool = false;
+    const ALLOW_NEGATIVE: bool = true;
+    const WITH_DAYS: bool = false;
+}
 
-    fn from_str(mut text: &str) -> Result<Self, ParseError> {
-        // It's faster to use `strip_prefix` with char literals if it's an ASCII
-        // char, otherwise prefer using string literals.
-        #[allow(clippy::single_char_pattern)]
-        let negate =
-            if let Some(remainder) = text.strip_prefix('-').or_else(|| text.strip_prefix("−")) {
-                text = remainder;
-                true
-            } else {
-                false
-            };
+struct DefaultParser;
 
-        let (seconds_text, nanos) =
-            if let Some((seconds, mut nanos)) = AsciiChar::DOT.split_once(text) {
-                if nanos.len() > 9 {
-                    nanos = nanos.get(..9).context(FractionDigits)?;
-                }
-                (
-                    seconds,
-                    nanos.parse::<u32>().context(Fraction)? * 10_u32.pow(9 - nanos.len() as u32),
-                )
+impl CustomParser for DefaultParser {}
+
+pub(crate) fn parse_custom<T: CustomParser>(mut text: &str) -> Result<TimeSpan, ParseError> {
+    // It's faster to use `strip_prefix` with char literals if it's an ASCII
+    // char, otherwise prefer using string literals.
+    #[allow(clippy::single_char_pattern)]
+    let negate = if T::ALLOW_NEGATIVE {
+        if let Some(remainder) = text.strip_prefix('-').or_else(|| {
+            if T::ASCII_ONLY {
+                None
             } else {
-                (text, 0u32)
-            };
+                text.strip_prefix("−")
+            }
+        }) {
+            text = remainder;
+            true
+        } else {
+            false
+        }
+    } else {
+        false
+    };
 
-        ensure!(!seconds_text.is_empty(), Empty);
+    let (mut rem, nanos) = if let Some((seconds, mut nanos)) = AsciiChar::DOT.split_once(text) {
+        if nanos.len() > 9 {
+            nanos = nanos.get(..9).context(FractionDigits)?;
+        }
+        (
+            seconds,
+            nanos.parse::<u32>().context(Fraction)? * 10_u32.pow(9 - nanos.len() as u32),
+        )
+    } else {
+        (text, 0u32)
+    };
+
+    let mut seconds = 0u64;
+
+    let mut factor = 1;
+    let max_pieces = const {
+        if T::WITH_DAYS {
+            4
+        } else {
+            3
+        }
+    };
+    for i in 0.. {
+        if i == max_pieces {
+            return Err(ParseError::TooManyColons);
+        }
+        match AsciiChar::COLON.rsplit_once(rem) {
+            Some((new_rem, piece)) => {
+                rem = new_rem;
+                let piece = piece.parse::<u64>().context(Piece)?;
+                let max = if i < 3 { 60 } else { 24 };
+                if piece >= max {
+                    return Err(ParseError::PieceOverflow);
+                }
+                seconds = piece
+                    .checked_mul(factor)
+                    .context(Overflow)?
+                    .checked_add(seconds)
+                    .context(Overflow)?;
+                factor *= max;
+            }
+            None => {
+                let piece = rem.parse::<u64>().context(Piece)?;
+                seconds = piece
+                    .checked_mul(factor)
+                    .context(Overflow)?
+                    .checked_add(seconds)
+                    .context(Overflow)?;
+                break;
+            }
+        }
+    }
 
-        let mut seconds = 0u64;
+    let (mut seconds, mut nanos) = (
+        i64::try_from(seconds).ok().context(Overflow)?,
+        i32::try_from(nanos).ok().context(Overflow)?,
+    );
 
-        for split in AsciiChar::COLON.split_iter(seconds_text) {
-            seconds = seconds
-                .checked_mul(60)
-                .context(Overflow)?
-                .checked_add(split.parse::<u64>().context(Time)?)
-                .context(Overflow)?;
-        }
+    if T::ALLOW_NEGATIVE && negate {
+        seconds = -seconds;
+        nanos = -nanos;
+    }
 
-        let (mut seconds, mut nanos) = (
-            i64::try_from(seconds).ok().context(Overflow)?,
-            i32::try_from(nanos).ok().context(Overflow)?,
-        );
+    Ok(Duration::new(seconds, nanos).into())
+}
 
-        if negate {
-            seconds = -seconds;
-            nanos = -nanos;
-        }
+impl FromStr for TimeSpan {
+    type Err = ParseError;
 
-        Ok(Duration::new(seconds, nanos).into())
+    #[inline]
+    fn from_str(text: &str) -> Result<Self, ParseError> {
+        parse_custom::<DefaultParser>(text)
     }
 }
 
@@ -237,16 +291,44 @@ mod tests {
         TimeSpan::from_str("-100").unwrap();
         TimeSpan::from_str("--30").unwrap_err();
         TimeSpan::from_str("-").unwrap_err();
-        TimeSpan::from_str("").unwrap_err();
         TimeSpan::from_str("-10:-30").unwrap_err();
         TimeSpan::from_str("10:-30").unwrap_err();
         TimeSpan::from_str("10.5:30.5").unwrap_err();
         TimeSpan::from_str("NaN").unwrap_err();
         TimeSpan::from_str("Inf").unwrap_err();
         assert!(matches!(
-            TimeSpan::from_str("1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1"),
-            Err(ParseError::Overflow),
+            TimeSpan::from_str(""),
+            Err(ParseError::Piece {
+                source: ParseIntError { .. }
+            })
         ));
+        assert_eq!(
+            TimeSpan::from_str("60")
+                .unwrap()
+                .to_seconds_and_subsec_nanoseconds(),
+            (60, 0)
+        );
+        assert_eq!(TimeSpan::from_str("0:60"), Err(ParseError::PieceOverflow));
+        assert_eq!(
+            TimeSpan::from_str("60:00")
+                .unwrap()
+                .to_seconds_and_subsec_nanoseconds(),
+            (3600, 0)
+        );
+        assert_eq!(
+            TimeSpan::from_str("0:60:00"),
+            Err(ParseError::PieceOverflow)
+        );
+        assert_eq!(
+            TimeSpan::from_str("24:00:00")
+                .unwrap()
+                .to_seconds_and_subsec_nanoseconds(),
+            (86400, 0)
+        );
+        assert_eq!(
+            TimeSpan::from_str("0:24:00:00"),
+            Err(ParseError::TooManyColons),
+        );
         assert_eq!(
             TimeSpan::from_str("10.123456789")
                 .unwrap()
diff --git a/src/util/ascii_char.rs b/src/util/ascii_char.rs
index 206ded11..0ae469a5 100644
--- a/src/util/ascii_char.rs
+++ b/src/util/ascii_char.rs
@@ -1,5 +1,3 @@
-use core::iter;
-
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct AsciiChar(u8);
@@ -38,28 +36,19 @@ impl AsciiChar {
         memchr::memchr(self.0, text.as_bytes()).is_some()
     }
 
-    pub fn split_once(self, text: &str) -> Option<(&str, &str)> {
-        let pos = memchr::memchr(self.0, text.as_bytes())?;
+    pub fn rsplit_once(self, text: &str) -> Option<(&str, &str)> {
+        let pos = memchr::memrchr(self.0, text.as_bytes())?;
         // SAFETY: memchr guarantees that the position is valid. Also since we
         // are looking for ASCII bytes, splitting at the position is guaranteed
         // to be valid UTF-8.
         unsafe { Some((text.get_unchecked(..pos), text.get_unchecked(pos + 1..))) }
     }
 
-    pub fn split_iter(self, text: &str) -> impl Iterator<Item = &str> {
-        let mut slot = Some(text);
-        iter::from_fn(move || {
-            let rem = slot?;
-            Some(match self.split_once(rem) {
-                Some((before, after)) => {
-                    slot = Some(after);
-                    before
-                }
-                None => {
-                    slot = None;
-                    rem
-                }
-            })
-        })
+    pub fn split_once(self, text: &str) -> Option<(&str, &str)> {
+        let pos = memchr::memchr(self.0, text.as_bytes())?;
+        // SAFETY: memchr guarantees that the position is valid. Also since we
+        // are looking for ASCII bytes, splitting at the position is guaranteed
+        // to be valid UTF-8.
+        unsafe { Some((text.get_unchecked(..pos), text.get_unchecked(pos + 1..))) }
     }
 }
diff --git a/tests/run_files/flitter.json b/tests/run_files/flitter.json
new file mode 100644
index 00000000..df5439c4
--- /dev/null
+++ b/tests/run_files/flitter.json
@@ -0,0 +1,81 @@
+{
+  "title": "Super Monkey Ball 2: Monkeyed Ball",
+  "category": "Story Mode All Levels",
+  "attempts": 3316,
+  "completed": 30,
+  "split_names": [
+    "World 1",
+    "World 2",
+    "World 3",
+    "World 4",
+    "World 5",
+    "World 6",
+    "World 7",
+    "World 8",
+    "World 9",
+    "World 10"
+  ],
+  "golds": [
+    {
+      "duration": "2:11.832"
+    },
+    {
+      "duration": "2:19.000"
+    },
+    null,
+    {
+      "duration": "2:16.000"
+    },
+    {
+      "duration": "2:09.133"
+    },
+    {
+      "duration": "2:24.000"
+    },
+    {
+      "duration": "2:34.258"
+    },
+    {
+      "duration": "2:28.164"
+    },
+    {
+      "duration": "2:29.000"
+    },
+    {
+      "duration": "4:02.718"
+    }
+  ],
+  "personal_best": {
+    "attempt": 3300,
+    "splits": [
+      {
+        "time": "2:13.254"
+      },
+      {
+        "time": "4:38.476"
+      },
+      {
+        "time": "6:40.419"
+      },
+      {
+        "time": "9:01.785"
+      },
+      {
+        "time": "11:10.919"
+      },
+      {
+        "time": "13:48.517"
+      },
+      null,
+      {
+        "time": "18:52.920"
+      },
+      {
+        "time": "21:30.001"
+      },
+      {
+        "time": "25:32.719"
+      }
+    ]
+  }
+}
diff --git a/tests/run_files/mod.rs b/tests/run_files/mod.rs
index 94e8c3fe..8531bac1 100644
--- a/tests/run_files/mod.rs
+++ b/tests/run_files/mod.rs
@@ -1,8 +1,7 @@
 #![allow(dead_code)]
 
 pub const CELESTE: &str = include_str!("Celeste - Any% (1.2.1.5).lss");
-pub const FLITTER_SMALL: &str = include_str!("flitter-small.scm");
-pub const FLITTER: &str = include_str!("flitter.scm");
+pub const FLITTER: &str = include_str!("flitter.json");
 pub const GENERIC_SPLITS_IO: &str = include_str!("generic_splits_io.json");
 pub const LIVESPLIT_1_0: &str = include_str!("livesplit1.0.lss");
 pub const LIVESPLIT_1_4: &str = include_str!("livesplit1.4.lss");
diff --git a/tests/split_parsing.rs b/tests/split_parsing.rs
index 712a66ba..8ae0144d 100644
--- a/tests/split_parsing.rs
+++ b/tests/split_parsing.rs
@@ -145,11 +145,6 @@ mod parse {
         flitter::parse(run_files::FLITTER).unwrap();
     }
 
-    #[test]
-    fn flitter_small() {
-        flitter::parse(run_files::FLITTER_SMALL).unwrap();
-    }
-
     #[test]
     fn source_live_timer() {
         source_live_timer::parse(run_files::SOURCE_LIVE_TIMER).unwrap();
@@ -220,8 +215,5 @@ mod parse {
     fn flitter_prefers_parsing_as_itself() {
         let run = composite::parse(run_files::FLITTER.as_bytes(), None).unwrap();
         assert_eq!(run.kind, TimerKind::Flitter);
-
-        let run = composite::parse(run_files::FLITTER_SMALL.as_bytes(), None).unwrap();
-        assert_eq!(run.kind, TimerKind::Flitter);
     }
 }