diff --git a/data/consoles/CGB/C16416396/metadata.json b/data/consoles/CGB/C16416396/metadata.json
index 09bd9108e..947c95c94 100644
--- a/data/consoles/CGB/C16416396/metadata.json
+++ b/data/consoles/CGB/C16416396/metadata.json
@@ -27,7 +27,7 @@
       "label": "CGB-REG IR3E06N 9937 C"
     },
     "x1": {
-      "label": "8388 KSS 9J"
+      "label": "8388 KSS9J"
     }
   }
 }
diff --git a/model/src/config/cartridge.rs b/model/src/config/cartridge.rs
index 67d4b766a..71c4cd4b1 100644
--- a/model/src/config/cartridge.rs
+++ b/model/src/config/cartridge.rs
@@ -17,13 +17,11 @@ use std::{
 use crate::{
     hash::{Crc32, Md5, Sha1, Sha256},
     parser::{
-        agb_mask_rom_tsop_ii_44_3v3, analog,
-        crystal_32kihz::crystal_32kihz,
-        eeprom::{eeprom_sop_8_3v3, eeprom_tssop_8_5v},
+        agb_mask_rom_tsop_ii_44_3v3, analog, eeprom_sop_8_3v3, eeprom_tssop_8_5v,
         flash_tsop_i_32_3v3, flash_tsop_i_40_5v, fram_sop_28_3v3, gb_mask_rom_glop_top_28_5v,
         gb_mask_rom_qfp_44_5v, gb_mask_rom_sop_32_5v, gb_mask_rom_sop_44_5v,
         gb_mask_rom_tsop_i_32_5v, gb_mask_rom_tsop_ii_44_5v, hex_inverter, line_decoder, mapper,
-        rtc_sop_20, rtc_sop_8,
+        rtc_crystal, rtc_sop_20, rtc_sop_8,
         sram::{sram_sop_28_3v3, sram_sop_28_5v, sram_sop_32_5v, sram_tsop_i_28},
         supervisor_reset,
         tama::{tama5, tama6, tama7},
@@ -189,7 +187,7 @@ impl BoardConfig {
                 D::U2 => Some(BoardPart::Flash(flash_tsop_i_32_3v3())),
                 // SOP-8 RTC
                 D::U3 => Some(BoardPart::Rtc(rtc_sop_8())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::AgbE06 => match designator {
@@ -227,7 +225,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Rtc(rtc_sop_8())),
                 D::U4 => Some(BoardPart::Unknown(unknown_chip())),
                 D::U5 => Some(BoardPart::Unknown(unknown_chip())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::AgbE24 => match designator {
@@ -248,7 +246,7 @@ impl BoardConfig {
                 D::U4 => Some(BoardPart::Rtc(rtc_sop_20())),
                 // SOP-8 M62021P
                 D::U5 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::Aaac => match designator {
@@ -468,7 +466,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Ram(sram_sop_28_5v())),
                 // SOP-8 26A / MM1134
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgKfcn | BoardConfig::DmgKfdn => match designator {
@@ -480,7 +478,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Ram(sram_sop_28_5v())),
                 // SOP-8 MM1134
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgKgdu => match designator {
@@ -492,7 +490,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Ram(sram_sop_28_5v())),
                 // SOP-8 MM1134
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgLfdn => match designator {
@@ -526,7 +524,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Ram(sram_sop_32_5v())),
                 // SOP-8 MM1134
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgTedn => match designator {
@@ -538,7 +536,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Ram(sram_sop_28_5v())),
                 // SOP-8 26A
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgTfdn => match designator {
@@ -550,7 +548,7 @@ impl BoardConfig {
                 D::U3 => Some(BoardPart::Ram(sram_sop_28_5v())),
                 // SOP-8 1134A
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgUedt => match designator {
@@ -564,7 +562,7 @@ impl BoardConfig {
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
                 // TSSOP-14
                 D::U5 => Some(BoardPart::HexInverter(hex_inverter())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgUfdt => match designator {
@@ -578,7 +576,7 @@ impl BoardConfig {
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
                 // TSSOP-14
                 D::U5 => Some(BoardPart::HexInverter(hex_inverter())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgUgdu => match designator {
@@ -592,7 +590,7 @@ impl BoardConfig {
                 D::U4 => Some(BoardPart::SupervisorReset(supervisor_reset())),
                 // TSSOP-14
                 D::U5 => Some(BoardPart::HexInverter(hex_inverter())),
-                D::X1 => Some(BoardPart::Crystal(crystal_32kihz())),
+                D::X1 => Some(BoardPart::Crystal(rtc_crystal())),
                 _ => None,
             },
             BoardConfig::DmgZ02 => match designator {
diff --git a/model/src/parser.rs b/model/src/parser.rs
index e0a72bb6a..9e87d80fa 100644
--- a/model/src/parser.rs
+++ b/model/src/parser.rs
@@ -5,6 +5,7 @@
 use log::warn;
 use nom::{combinator::all_consuming, error::VerboseError, IResult, Parser as _};
 use regex::{Captures, Regex, RegexBuilder};
+use stamp::{CgbStamp, DmgStamp};
 use std::str::FromStr;
 
 use crate::{
@@ -13,33 +14,20 @@ use crate::{
 };
 
 pub use self::{
-    ags_charge_ctrl::AgsChargeController,
-    cgb_stamp::CgbStamp,
-    coil::Coil,
-    dmg_stamp::DmgStamp,
-    eeprom::Eeprom,
     lcd_chip::LcdChip,
     lcd_screen::LcdScreen,
     mapper::{Huc1Version, Mapper, MapperType, Mbc1Version, Mbc2Version, Mbc3Version},
 };
 
-pub mod ags_charge_ctrl;
 pub mod amic;
 pub mod analog;
 pub mod atmel;
 pub mod bsi;
-pub mod cgb_stamp;
-pub mod coil;
-pub mod crystal_20mihz;
-pub mod crystal_32kihz;
-pub mod crystal_32mihz;
-pub mod crystal_4mihz;
-pub mod crystal_8mihz;
-pub mod dmg_stamp;
-pub mod eeprom;
 pub mod fujitsu;
 pub mod hynix;
 pub mod hyundai;
+pub mod kds;
+pub mod kinseki;
 pub mod lcd_chip;
 pub mod lcd_screen;
 pub mod lgs;
@@ -50,20 +38,20 @@ pub mod mitsubishi;
 pub mod mitsumi;
 pub mod nec;
 pub mod oki;
-pub mod oxy_u4;
-pub mod oxy_u5;
 pub mod rohm;
 pub mod samsung;
 pub mod sanyo;
 pub mod seiko;
-pub mod sgb_rom;
 pub mod sharp;
 pub mod sram;
 pub mod sst;
 pub mod st_micro;
+pub mod stamp;
 pub mod tama;
+pub mod tdk;
 pub mod ti;
 pub mod toshiba;
+pub mod unknown;
 pub mod victronix;
 pub mod winbond;
 
@@ -85,12 +73,15 @@ pub struct GenericPart {
 pub struct Crystal {
     pub manufacturer: Option<Manufacturer>,
     pub frequency: u32,
-    pub year: Option<Year>,
-    pub month: Option<Month>,
-    pub week: Option<Week>,
+    pub date_code: Option<PartDateCode>,
 }
 
 impl Crystal {
+    pub const FREQ_32_KIHZ: u32 = 32_768;
+    pub const FREQ_4_MIHZ: u32 = 4_194_304;
+    pub const FREQ_8_MIHZ: u32 = 8_388_608;
+    pub const FREQ_20_MIHZ: u32 = 20_971_520;
+    pub const FREQ_32_MIHZ: u32 = 33_554_432;
     pub fn format_frequency(&self) -> String {
         if self.frequency > 1_000_000 {
             format!(
@@ -106,29 +97,6 @@ impl Crystal {
     }
 }
 
-fn kds_month1(text: &str) -> Result<Month, String> {
-    month1_alpha(text)
-}
-
-fn month1_alpha(text: &str) -> Result<Month, String> {
-    match text {
-        "A" => Ok(Month::January),
-        "B" => Ok(Month::February),
-        "C" => Ok(Month::March),
-        "D" => Ok(Month::April),
-        "E" => Ok(Month::May),
-        "F" => Ok(Month::June),
-        "G" => Ok(Month::July),
-        "H" => Ok(Month::August),
-        // I is intentionally skipped
-        "J" => Ok(Month::September),
-        "K" => Ok(Month::October),
-        "L" => Ok(Month::November),
-        "M" => Ok(Month::December),
-        _ => Err(format!("Invalid 1-letter month: {}", text)),
-    }
-}
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum Manufacturer {
     Amic,
@@ -220,7 +188,7 @@ pub enum Year {
     Partial(u8),
 }
 
-pub fn year1(text: &str) -> Result<Year, String> {
+fn year1(text: &str) -> Result<Year, String> {
     if text.len() != 1 {
         return Err(format!("Invalid 1-digit year: {}", text));
     }
@@ -341,6 +309,14 @@ mod for_nom {
             .parse(input)
     }
 
+    pub fn year1_month1_abc<'a, E: ParseError<&'a str>>(
+        input: &'a str,
+    ) -> IResult<&'a str, PartDateCode, E> {
+        tuple((year1, month1_abc))
+            .map(|(year, month)| PartDateCode::YearMonth { year, month })
+            .parse(input)
+    }
+
     pub fn month1_123abc<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Month, E> {
         map_opt(take(1_usize), |text| match text {
             "1" => Some(Month::January),
@@ -408,6 +384,15 @@ mod for_nom {
         .parse(input)
     }
 
+    pub fn month2<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Month, E> {
+        map_opt(take(2_usize), |text| {
+            u8::from_str_radix(text, 10)
+                .ok()
+                .and_then(|v| Month::try_from(v).ok())
+        })
+        .parse(input)
+    }
+
     fn line_sep<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, char, E> {
         alt((char(' '), char('\n'))).parse(input)
     }
@@ -448,7 +433,7 @@ mod for_nom {
     }
 }
 
-pub fn year2(text: &str) -> Result<Year, String> {
+fn year2(text: &str) -> Result<Year, String> {
     if text.len() != 2 {
         return Err(format!("Invalid 2-digit year: {}", text));
     }
@@ -465,7 +450,7 @@ pub fn year2(text: &str) -> Result<Year, String> {
     }
 }
 
-pub fn week2(text: &str) -> Result<Week, String> {
+fn week2(text: &str) -> Result<Week, String> {
     if text.len() != 2 {
         return Err(format!("Invalid 2-digit week: {}", text));
     }
@@ -475,7 +460,7 @@ pub fn week2(text: &str) -> Result<Week, String> {
         .ok_or_else(|| format!("Invalid 2-digit week: {}", text))
 }
 
-pub fn month2(text: &str) -> Result<Month, String> {
+fn month2(text: &str) -> Result<Month, String> {
     if text.len() != 2 {
         return Err(format!("Invalid 2-digit month: {}", text));
     }
@@ -636,6 +621,22 @@ pub fn oxy_pmic() -> &'static impl LabelParser<GenericPart> {
     &mitsumi::MITSUMI_PM
 }
 
+pub fn oxy_u4() -> &'static impl LabelParser<GenericPart> {
+    &unknown::UNKNOWN_OXY_U4
+}
+
+pub fn oxy_u5() -> &'static impl LabelParser<GenericPart> {
+    &unknown::UNKNOWN_OXY_U5
+}
+
+pub fn ags_charge_ctrl() -> &'static impl LabelParser<GenericPart> {
+    multi_parser!(
+        GenericPart,
+        &mitsumi::MITSUMI_MM1581A,
+        &unknown::UNKNOWN_AGS_CHARGE_CONTROLLER
+    )
+}
+
 pub fn ags_pmic_new() -> &'static impl LabelParser<GenericPart> {
     &mitsumi::MITSUMI_PM
 }
@@ -678,6 +679,88 @@ pub fn icd2() -> &'static impl LabelParser<GenericPart> {
     )
 }
 
+pub fn sgb_rom() -> &'static impl LabelParser<MaskRom> {
+    multi_parser!(
+        MaskRom,
+        &toshiba::TOSHIBA_SGB_ROM,
+        &sharp::SHARP_SGB_ROM,
+        &fujitsu::FUJITSU_SGB_ROM,
+        &unknown::UNKNOWN_SGB_ROM,
+        &nec::NEC_SGB_ROM,
+    )
+}
+
+pub fn sgb2_coil() -> &'static impl LabelParser<GenericPart> {
+    multi_parser!(GenericPart, &tdk::TDK_ZJY_M4A, &tdk::TDK_ZJY_M4PA,)
+}
+
+pub fn sgb2_rom() -> &'static impl LabelParser<MaskRom> {
+    multi_parser!(MaskRom, &sharp::SHARP_SGB2_ROM, &oki::OKI_SGB2_ROM,)
+}
+
+pub fn dmg_stamp() -> &'static impl LabelParser<DmgStamp> {
+    &stamp::DMG_STAMP
+}
+
+pub fn cgb_stamp() -> &'static impl LabelParser<CgbStamp> {
+    &stamp::CGB_STAMP
+}
+
+pub fn rtc_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(
+        Crystal,
+        &kds::KDS_32_KIHZ,
+        &unknown::UNKNOWN_CRYSTAL_32_KIHZ
+    )
+}
+
+pub fn dmg_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(
+        Crystal,
+        &kds::KDS_D419_OLD,
+        &unknown::UNKNOWN_DMG_CRYSTAL_4_MIHZ
+    )
+}
+
+pub fn mgb_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(
+        Crystal,
+        &kds::KDS_4_MIHZ_OLD,
+        &kinseki::KINSEKI_4_MIHZ,
+        &unknown::UNKNOWN_MGB_CRYSTAL_4_MIHZ
+    )
+}
+
+pub fn sgb2_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(Crystal, &kds::KDS_D209, &kinseki::KINSEKI_20_MIHZ,)
+}
+
+pub fn cgb_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(
+        Crystal,
+        &kds::KDS_D838,
+        &kds::KDS_8_MIHZ,
+        &kinseki::KINSEKI_8_MIHZ
+    )
+}
+
+pub fn agb_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(
+        Crystal,
+        &kds::KDS_D419_NEW,
+        &kds::KDS_4_MIHZ_NEW,
+        &kinseki::KINSEKI_4_MIHZ,
+    )
+}
+
+pub fn ags_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(Crystal, &kds::KDS_4_MIHZ_AGS, &kinseki::KINSEKI_4_MIHZ,)
+}
+
+pub fn gbs_crystal() -> &'static impl LabelParser<Crystal> {
+    multi_parser!(Crystal, &kinseki::KINSEKI_32_MIHZ,)
+}
+
 pub fn dmg_soc_qfp_80() -> &'static impl LabelParser<GenericPart> {
     multi_parser!(GenericPart, &sharp::SHARP_LR35902, &sharp::SHARP_DMG_CPU)
 }
@@ -888,3 +971,15 @@ pub fn gb_mask_rom_qfp_44_5v() -> &'static impl LabelParser<GameMaskRom> {
         &oki::OKI_MASK_ROM_QFP_44_512_KIBIT,
     )
 }
+
+pub fn eeprom_sop_8_3v3() -> &'static impl LabelParser<GenericPart> {
+    multi_parser!(GenericPart, &rohm::ROHM_9853, &rohm::ROHM_9854)
+}
+
+pub fn eeprom_tssop_8_5v() -> &'static impl LabelParser<GenericPart> {
+    multi_parser!(
+        GenericPart,
+        &unknown::UNKNOWN_LCS5_EEPROM,
+        &unknown::UNKNOWN_LC56_EEPROM
+    )
+}
diff --git a/model/src/parser/ags_charge_ctrl.rs b/model/src/parser/ags_charge_ctrl.rs
deleted file mode 100644
index b1dc1c769..000000000
--- a/model/src/parser/ags_charge_ctrl.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{week2, year1, GenericPart, LabelParser};
-use crate::{
-    macros::{multi_parser, single_parser},
-    parser::{mitsumi, PartDateCode},
-};
-
-pub type AgsChargeController = GenericPart;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::ags_charge_ctrl::unknown().parse("2253B 3129").is_ok());
-/// ```
-pub fn unknown() -> &'static impl LabelParser<AgsChargeController> {
-    single_parser!(
-        AgsChargeController,
-        r#"^2253B\ ([0-9])([0-9]{2})[0-9]$"#,
-        move |c| {
-            Ok(AgsChargeController {
-                kind: "2253B".to_owned(),
-                manufacturer: None,
-                date_code: Some(PartDateCode::YearWeek {
-                    year: year1(&c[1])?,
-                    week: week2(&c[2])?,
-                }),
-            })
-        }
-    )
-}
-
-pub fn ags_charge_ctrl() -> &'static impl LabelParser<AgsChargeController> {
-    multi_parser!(AgsChargeController, &mitsumi::MITSUMI_MM1581A, unknown())
-}
diff --git a/model/src/parser/cgb_stamp.rs b/model/src/parser/cgb_stamp.rs
deleted file mode 100644
index fecc81889..000000000
--- a/model/src/parser/cgb_stamp.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{week2, year1, LabelParser, Year};
-use crate::{macros::single_parser, time::Week};
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct CgbStamp {
-    pub year: Option<Year>,
-    pub week: Option<Week>,
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::cgb_stamp::cgb_stamp().parse("218-2221").is_ok());
-/// ```
-pub fn cgb_stamp() -> &'static impl LabelParser<CgbStamp> {
-    single_parser!(
-        CgbStamp,
-        r#"^([0-9]{2})([0-9])[-\ .X]?[0-9]{2,4}Y?$"#,
-        move |c| {
-            Ok(CgbStamp {
-                year: Some(year1(&c[2])?),
-                week: Some(week2(&c[1])?),
-            })
-        }
-    )
-}
diff --git a/model/src/parser/coil.rs b/model/src/parser/coil.rs
deleted file mode 100644
index de616ff99..000000000
--- a/model/src/parser/coil.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{LabelParser, Manufacturer};
-use crate::macros::{multi_parser, single_parser};
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Coil {
-    pub kind: String,
-    pub manufacturer: Option<Manufacturer>,
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::coil::tdk().parse("TDK ZJY-M4A N").is_ok());
-/// ```
-pub fn tdk() -> &'static impl LabelParser<Coil> {
-    single_parser!(Coil, r#"^TDK\ (ZJY-M4A)\ [A-Z]$"#, move |c| {
-        Ok(Coil {
-            kind: c[1].to_owned(),
-            manufacturer: Some(Manufacturer::Tdk),
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::coil::tdk2().parse("TDK ZJY-M4PA n").is_ok());
-/// ```
-pub fn tdk2() -> &'static impl LabelParser<Coil> {
-    single_parser!(Coil, r#"^TDK\ (ZJY-M4PA)\ [a-z]$"#, move |c| {
-        Ok(Coil {
-            kind: c[1].to_owned(),
-            manufacturer: Some(Manufacturer::Tdk),
-        })
-    })
-}
-
-pub fn coil() -> &'static impl LabelParser<Coil> {
-    multi_parser!(Coil, tdk(), tdk2())
-}
diff --git a/model/src/parser/crystal_20mihz.rs b/model/src/parser/crystal_20mihz.rs
deleted file mode 100644
index 4b892fc81..000000000
--- a/model/src/parser/crystal_20mihz.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{kds_month1, year1, Crystal, LabelParser, Manufacturer};
-use crate::macros::{multi_parser, single_parser};
-
-const FREQUENCY: u32 = 20_971_520;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_20mihz::kds_d209().parse("D209A8").is_ok());
-/// ```
-pub fn kds_d209() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^D209([A-Z])([0-9])$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kds),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[2])?),
-            month: Some(kds_month1(&c[1])?),
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_20mihz::kinseki_kss20().parse("KSS20V 8A").is_ok());
-/// ```
-pub fn kinseki_kss20() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^KSS20V\ ([0-9])([A-Z])$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kinseki),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: Some(kds_month1(&c[2])?),
-            week: None,
-        })
-    })
-}
-
-pub fn crystal_20mihz() -> &'static impl LabelParser<Crystal> {
-    multi_parser!(Crystal, kds_d209(), kinseki_kss20(),)
-}
diff --git a/model/src/parser/crystal_32kihz.rs b/model/src/parser/crystal_32kihz.rs
deleted file mode 100644
index 3eb53b0c9..000000000
--- a/model/src/parser/crystal_32kihz.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{kds_month1, year1, Crystal, LabelParser, Manufacturer};
-use crate::macros::{multi_parser, single_parser};
-
-const FREQUENCY: u32 = 32_768;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_32kihz::kds_short().parse("KDS1H").is_ok());
-/// ```
-pub fn kds_short() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^KDS([0-9])([A-Z])$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kds),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: Some(kds_month1(&c[2])?),
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_32kihz::unknown().parse("32K09").is_ok());
-/// assert!(parser::crystal_32kihz::unknown().parse("32K9Y").is_ok());
-/// assert!(parser::crystal_32kihz::unknown().parse("32K0Z").is_ok());
-/// ```
-pub fn unknown() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^32K([0-9])[[:alnum:]]$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: None,
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: None,
-            week: None,
-        })
-    })
-}
-
-pub fn crystal_32kihz() -> &'static impl LabelParser<Crystal> {
-    multi_parser!(Crystal, kds_short(), unknown(),)
-}
diff --git a/model/src/parser/crystal_32mihz.rs b/model/src/parser/crystal_32mihz.rs
deleted file mode 100644
index 930ca8d82..000000000
--- a/model/src/parser/crystal_32mihz.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{kds_month1, year1, Crystal, LabelParser, Manufacturer};
-use crate::macros::single_parser;
-
-const FREQUENCY: u32 = 33_554_432;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_32mihz::kinseki_kss30().parse("33WKSS6DT").is_ok());
-/// ```
-pub fn kinseki_kss30() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^33WKSS([0-9])([A-Z])T$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kinseki),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: Some(kds_month1(&c[2])?),
-            week: None,
-        })
-    })
-}
-pub fn crystal_32mihz() -> &'static impl LabelParser<Crystal> {
-    kinseki_kss30()
-}
diff --git a/model/src/parser/crystal_4mihz.rs b/model/src/parser/crystal_4mihz.rs
deleted file mode 100644
index 85bce6de6..000000000
--- a/model/src/parser/crystal_4mihz.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{kds_month1, week2, year1, year2, Crystal, LabelParser, Manufacturer};
-use crate::macros::{multi_parser, single_parser};
-
-const FREQUENCY: u32 = 4_194_304;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::kds_4194().parse("KDS 9803 4.194").is_ok());
-/// assert!(parser::crystal_4mihz::kds_4194().parse("KDS9807 4.194").is_ok());
-/// assert!(parser::crystal_4mihz::kds_4194().parse("KDSI 0549 4.194").is_ok());
-/// ```
-pub fn kds_4194() -> &'static impl LabelParser<Crystal> {
-    single_parser!(
-        Crystal,
-        r#"^KDSI?\ ?([0-9]{2})([0-9]{2})\ 4\.194$"#,
-        move |c| {
-            Ok(Crystal {
-                manufacturer: Some(Manufacturer::Kds),
-                frequency: FREQUENCY,
-                year: Some(year2(&c[1])?),
-                month: None,
-                week: Some(week2(&c[2])?),
-            })
-        }
-    )
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::kds_4194_short().parse("KDS 6F 4.194").is_ok());
-/// ```
-pub fn kds_4194_short() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^KDS\ ([0-9])([A-Z])\ 4\.194$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kds),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: Some(kds_month1(&c[2])?),
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::kds_d419().parse("D419A2").is_ok());
-/// assert!(parser::crystal_4mihz::kds_d419().parse("D419J3I").is_ok());
-/// ```
-pub fn kds_d419() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^D419([A-Z])([0-9])[A-Z]?$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kds),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[2])?),
-            month: Some(kds_month1(&c[1])?),
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::kinseki_4194().parse("4194 KSS 0KF").is_ok());
-/// assert!(parser::crystal_4mihz::kinseki_4194().parse("4194 KSS1A").is_ok());
-/// ```
-pub fn kinseki_4194() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^4194\ KSS\ ?([0-9])([A-Z])[A-Z]?$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kinseki),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: Some(kds_month1(&c[2])?),
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::unknown2().parse("4.19C59").is_ok());
-/// ```
-pub fn unknown2() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^4\.19C([0-9])[[:alnum:]]$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: None,
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: None,
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::unknown_41943().parse("4.1943 9752").is_ok());
-/// ```
-pub fn unknown_41943() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^4\.1943\ ([0-9]{2})([0-9]{2})$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: None,
-            frequency: FREQUENCY,
-            year: Some(year2(&c[1])?),
-            month: None,
-            week: Some(week2(&c[2])?),
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::unknown_41943_2().parse("4.1943 RVR 841").is_ok());
-/// ```
-pub fn unknown_41943_2() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^4\.1943\ RVR\ ([0-9])([0-9]{2})$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: None,
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: None,
-            week: Some(week2(&c[2])?),
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_4mihz::unknown2().parse("4.19C59").is_ok());
-/// ```
-pub fn unknown() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^4\.19C([0-9])[[:alnum:]]$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: None,
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: None,
-            week: None,
-        })
-    })
-}
-
-pub fn crystal_4mihz() -> &'static impl LabelParser<Crystal> {
-    multi_parser!(
-        Crystal,
-        kds_d419(),
-        unknown(),
-        kinseki_4194(),
-        kds_4194(),
-        kds_4194_short(),
-        unknown_41943(),
-        unknown_41943_2(),
-    )
-}
diff --git a/model/src/parser/crystal_8mihz.rs b/model/src/parser/crystal_8mihz.rs
deleted file mode 100644
index db68882f5..000000000
--- a/model/src/parser/crystal_8mihz.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{kds_month1, week2, year1, year2, Crystal, LabelParser, Manufacturer};
-use crate::macros::{multi_parser, single_parser};
-
-const FREQUENCY: u32 = 8_388_608;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_8mihz::kds_8388().parse("KDS 9841 8.388").is_ok());
-/// ```
-pub fn kds_8388() -> &'static impl LabelParser<Crystal> {
-    single_parser!(
-        Crystal,
-        r#"^KDS\ ([0-9]{2})([0-9]{2})\ 8\.388$"#,
-        move |c| {
-            Ok(Crystal {
-                manufacturer: Some(Manufacturer::Kds),
-                frequency: FREQUENCY,
-                year: Some(year2(&c[1])?),
-                month: None,
-                week: Some(week2(&c[2])?),
-            })
-        }
-    )
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_8mihz::kds_d838().parse("D838K0I").is_ok());
-/// ```
-pub fn kds_d838() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^D838([A-Z])([0-9])[A-Z]$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kds),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[2])?),
-            month: Some(kds_month1(&c[1])?),
-            week: None,
-        })
-    })
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::crystal_8mihz::kinseki_8388().parse("8388 KSS 1CF").is_ok());
-/// assert!(parser::crystal_8mihz::kinseki_8388().parse("8388 KSS 9J").is_ok());
-/// ```
-pub fn kinseki_8388() -> &'static impl LabelParser<Crystal> {
-    single_parser!(Crystal, r#"^8388\ KSS\ ([0-9])([A-Z])[A-Z]?$"#, move |c| {
-        Ok(Crystal {
-            manufacturer: Some(Manufacturer::Kinseki),
-            frequency: FREQUENCY,
-            year: Some(year1(&c[1])?),
-            month: Some(kds_month1(&c[2])?),
-            week: None,
-        })
-    })
-}
-pub fn crystal_8mihz() -> &'static impl LabelParser<Crystal> {
-    multi_parser!(Crystal, kds_8388(), kds_d838(), kinseki_8388())
-}
diff --git a/model/src/parser/dmg_stamp.rs b/model/src/parser/dmg_stamp.rs
deleted file mode 100644
index 972a170cb..000000000
--- a/model/src/parser/dmg_stamp.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{month2, year1, LabelParser, Year};
-use crate::{macros::single_parser, time::Month};
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct DmgStamp {
-    pub year: Option<Year>,
-    pub month: Option<Month>,
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::dmg_stamp::dmg_stamp().parse("010 23").is_ok());
-/// assert!(parser::dmg_stamp::dmg_stamp().parse("903-22").is_ok());
-/// assert!(parser::dmg_stamp::dmg_stamp().parse("709.3901").is_ok());
-/// assert!(parser::dmg_stamp::dmg_stamp().parse("202-0007").is_ok());
-/// ```
-pub fn dmg_stamp() -> &'static impl LabelParser<DmgStamp> {
-    single_parser!(
-        DmgStamp,
-        r#"^([0-9])([0-9]{2})[-\ .][0-9-]{2,4}Y?$"#,
-        move |c| {
-            Ok(DmgStamp {
-                year: Some(year1(&c[1])?),
-                month: Some(month2(&c[2])?),
-            })
-        }
-    )
-}
diff --git a/model/src/parser/eeprom.rs b/model/src/parser/eeprom.rs
deleted file mode 100644
index 0c0c349c7..000000000
--- a/model/src/parser/eeprom.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use nom::{
-    bytes::streaming::tag, character::streaming::char, combinator::opt, sequence::tuple,
-    Parser as _,
-};
-
-use super::{
-    for_nom::{digits, uppers, year1_week2},
-    GenericPart, LabelParser, NomParser,
-};
-use crate::{macros::multi_parser, parser::rohm};
-
-pub type Eeprom = GenericPart;
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::eeprom::LCS5.parse("LCS5 040").is_ok());
-/// assert!(parser::eeprom::LCS5.parse("LCS5 435 09").is_ok());
-/// ```
-pub static LCS5: NomParser<Eeprom> = NomParser {
-    name: "LCS5",
-    f: |input| {
-        tuple((
-            tag("LCS5 "),
-            year1_week2,
-            opt(tuple((nom::character::complete::char(' '), digits(2)))),
-        ))
-        .map(|(_, date_code, _)| Eeprom {
-            kind: "LC56".to_owned(),
-            manufacturer: None,
-            date_code: Some(date_code),
-        })
-        .parse(input)
-    },
-};
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::eeprom::LC56.parse("LC56 W617 08").is_ok());
-/// ```
-pub static LC56: NomParser<Eeprom> = NomParser {
-    name: "LC56",
-    f: |input| {
-        tuple((tag("LC56 "), uppers(1).and(digits(3)), char(' '), digits(2)))
-            .map(|(_, _, _, _)| Eeprom {
-                kind: "LC56".to_owned(),
-                manufacturer: None,
-                date_code: None,
-            })
-            .parse(input)
-    },
-};
-
-pub fn eeprom_sop_8_3v3() -> &'static impl LabelParser<Eeprom> {
-    multi_parser!(Eeprom, &rohm::ROHM_9853, &rohm::ROHM_9854)
-}
-
-pub fn eeprom_tssop_8_5v() -> &'static impl LabelParser<Eeprom> {
-    multi_parser!(Eeprom, &LCS5, &LC56)
-}
diff --git a/model/src/parser/kds.rs b/model/src/parser/kds.rs
new file mode 100644
index 000000000..b381a50e3
--- /dev/null
+++ b/model/src/parser/kds.rs
@@ -0,0 +1,188 @@
+// SPDX-FileCopyrightText: Joonas Javanainen <joonas.javanainen@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+use nom::{
+    branch::alt,
+    bytes::streaming::tag,
+    combinator::opt,
+    error::ParseError,
+    sequence::{terminated, tuple},
+    IResult, Parser as _,
+};
+
+use super::{
+    for_nom::{lines2, month1_abc, uppers, year1, year1_month1_abc, year2_week2},
+    Crystal, Manufacturer, NomParser, PartDateCode,
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_32_KIHZ.parse("KDS1H").is_ok());
+/// ```
+pub static KDS_32_KIHZ: NomParser<Crystal> = NomParser {
+    name: "KDS 32 KiHz",
+    f: |input| {
+        tuple((tag("KDS"), year1_month1_abc))
+            .map(|(_, date_code)| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_32_KIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_4_MIHZ_OLD.parse("KDS9807 4.194").is_ok());
+/// assert!(parser::kds::KDS_4_MIHZ_OLD.parse("KDS 9803 4.194").is_ok());
+/// assert!(parser::kds::KDS_4_MIHZ_OLD.parse("KDS 6F 4.194").is_ok());
+/// ```
+pub static KDS_4_MIHZ_OLD: NomParser<Crystal> = NomParser {
+    name: "KDS 4 MiHz",
+    f: |input| {
+        lines2(
+            terminated(tag("KDS"), opt(nom::character::complete::char(' ')))
+                .and(alt((year1_month1_abc, year2_week2))),
+            tag("4.194"),
+        )
+        .map(|((_, date_code), _)| Crystal {
+            manufacturer: Some(Manufacturer::Kds),
+            frequency: Crystal::FREQ_4_MIHZ,
+            date_code: Some(date_code),
+        })
+        .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_4_MIHZ_NEW.parse("KDS 0102 4.194").is_ok());
+/// ```
+pub static KDS_4_MIHZ_NEW: NomParser<Crystal> = NomParser {
+    name: "KDS 4 MiHz",
+    f: |input| {
+        lines2(tag("KDS ").and(year2_week2), tag("4.194"))
+            .map(|((_, date_code), _)| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_4_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_4_MIHZ_AGS.parse("KDSI 0549 4.194").is_ok());
+/// ```
+pub static KDS_4_MIHZ_AGS: NomParser<Crystal> = NomParser {
+    name: "KDS 4 MiHz",
+    f: |input| {
+        lines2(tag("KDSI ").and(year2_week2), tag("4.194"))
+            .map(|((_, date_code), _)| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_4_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_8_MIHZ.parse("KDS 9841 8.388").is_ok());
+/// ```
+pub static KDS_8_MIHZ: NomParser<Crystal> = NomParser {
+    name: "KDS 8 MiHz",
+    f: |input| {
+        lines2(tag("KDS ").and(year2_week2), tag("8.388"))
+            .map(|((_, date_code), _)| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_8_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_D419_OLD.parse("D419A2").is_ok());
+/// ```
+pub static KDS_D419_OLD: NomParser<Crystal> = NomParser {
+    name: "KDS D419",
+    f: |input| {
+        tag("D419")
+            .and(month1_abc_year1)
+            .map(|(_, date_code)| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_4_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_D419_NEW.parse("D419J3I").is_ok());
+/// ```
+pub static KDS_D419_NEW: NomParser<Crystal> = NomParser {
+    name: "KDS D419",
+    f: |input| {
+        tag("D419")
+            .and(month1_abc_year1.and(uppers(1)))
+            .map(|(_, (date_code, _))| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_4_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_D838.parse("D838K0I").is_ok());
+/// ```
+pub static KDS_D838: NomParser<Crystal> = NomParser {
+    name: "KDS D838",
+    f: |input| {
+        tag("D838")
+            .and(month1_abc_year1.and(uppers(1)))
+            .map(|(_, (date_code, _))| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_8_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kds::KDS_D209.parse("D209A8").is_ok());
+/// ```
+pub static KDS_D209: NomParser<Crystal> = NomParser {
+    name: "KDS D209",
+    f: |input| {
+        tag("D209")
+            .and(month1_abc_year1)
+            .map(|(_, date_code)| Crystal {
+                manufacturer: Some(Manufacturer::Kds),
+                frequency: Crystal::FREQ_20_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+fn month1_abc_year1<'a, E: ParseError<&'a str>>(
+    input: &'a str,
+) -> IResult<&'a str, PartDateCode, E> {
+    tuple((month1_abc, year1))
+        .map(|(month, year)| PartDateCode::YearMonth { year, month })
+        .parse(input)
+}
diff --git a/model/src/parser/kinseki.rs b/model/src/parser/kinseki.rs
new file mode 100644
index 000000000..b12708fba
--- /dev/null
+++ b/model/src/parser/kinseki.rs
@@ -0,0 +1,106 @@
+// SPDX-FileCopyrightText: Joonas Javanainen <joonas.javanainen@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+use nom::{
+    branch::alt,
+    bytes::streaming::tag,
+    character::streaming::char,
+    sequence::{delimited, tuple},
+    Parser as _,
+};
+
+use super::{
+    for_nom::{lines2, uppers, year1_month1_abc},
+    Crystal, Manufacturer, NomParser,
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kinseki::KINSEKI_4_MIHZ.parse("4194 KSS 0KF").is_ok());
+/// assert!(parser::kinseki::KINSEKI_4_MIHZ.parse("4194 KSS1A").is_ok());
+/// ```
+pub static KINSEKI_4_MIHZ: NomParser<Crystal> = NomParser {
+    name: "Kinseki 4 MiHz",
+    f: |input| {
+        lines2(
+            tag("4194"),
+            tuple((
+                tag("KSS"),
+                alt((
+                    delimited(char(' '), year1_month1_abc, uppers(1)),
+                    year1_month1_abc,
+                )),
+            )),
+        )
+        .map(|(_, (_, date_code))| Crystal {
+            manufacturer: Some(Manufacturer::Kinseki),
+            frequency: Crystal::FREQ_4_MIHZ,
+            date_code: Some(date_code),
+        })
+        .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kinseki::KINSEKI_8_MIHZ.parse("8388 KSS 1CF").is_ok());
+/// assert!(parser::kinseki::KINSEKI_8_MIHZ.parse("8388 KSS9J").is_ok());
+/// ```
+pub static KINSEKI_8_MIHZ: NomParser<Crystal> = NomParser {
+    name: "Kinseki 8 MiHz",
+    f: |input| {
+        lines2(
+            tag("8388"),
+            tuple((
+                tag("KSS"),
+                alt((
+                    delimited(char(' '), year1_month1_abc, uppers(1)),
+                    year1_month1_abc,
+                )),
+            )),
+        )
+        .map(|(_, (_, date_code))| Crystal {
+            manufacturer: Some(Manufacturer::Kinseki),
+            frequency: Crystal::FREQ_8_MIHZ,
+            date_code: Some(date_code),
+        })
+        .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kinseki::KINSEKI_20_MIHZ.parse("KSS20V 8A").is_ok());
+/// ```
+pub static KINSEKI_20_MIHZ: NomParser<Crystal> = NomParser {
+    name: "Kinseki 20 MiHz",
+    f: |input| {
+        tag("KSS20V ")
+            .and(year1_month1_abc)
+            .map(|(_, date_code)| Crystal {
+                manufacturer: Some(Manufacturer::Kinseki),
+                frequency: Crystal::FREQ_20_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::kinseki::KINSEKI_32_MIHZ.parse("33WKSS6DT").is_ok());
+/// ```
+pub static KINSEKI_32_MIHZ: NomParser<Crystal> = NomParser {
+    name: "Kinseki 32 MiHz",
+    f: |input| {
+        tag("33WKSS")
+            .and(year1_month1_abc.and(char('T')))
+            .map(|(_, (date_code, _))| Crystal {
+                manufacturer: Some(Manufacturer::Kinseki),
+                frequency: Crystal::FREQ_32_MIHZ,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
diff --git a/model/src/parser/oki.rs b/model/src/parser/oki.rs
index 6612fedb1..986d63fb8 100644
--- a/model/src/parser/oki.rs
+++ b/model/src/parser/oki.rs
@@ -231,14 +231,14 @@ pub static OKI_MR27V12813: NomParser<GameMaskRom> = NomParser {
     f: |input| gba("M", "R27V12813M", GameRomType::J2).parse(input),
 };
 
-/// OKI SGB mask ROM, MSM534011 (SOP-32, 5V, 4 Mibit / 512 KiB)
+/// OKI SGB2 mask ROM, MSM534011 (SOP-32, 5V, 4 Mibit / 512 KiB)
 ///
 /// ```
 /// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::oki::OKI_SGB_ROM.parse("SYS-SGB2-10 © 1998 Nintendo M534011E-05 8012354").is_ok());
+/// assert!(parser::oki::OKI_SGB2_ROM.parse("SYS-SGB2-10 © 1998 Nintendo M534011E-05 8012354").is_ok());
 /// ```
-pub static OKI_SGB_ROM: NomParser<MaskRom> = NomParser {
-    name: "OKI SGB ROM",
+pub static OKI_SGB2_ROM: NomParser<MaskRom> = NomParser {
+    name: "OKI SGB2 ROM",
     f: |input| {
         tuple((
             tag("SYS-SGB2-10"),
diff --git a/model/src/parser/oxy_u4.rs b/model/src/parser/oxy_u4.rs
deleted file mode 100644
index 52f08bb04..000000000
--- a/model/src/parser/oxy_u4.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{week2, year1, GenericPart, LabelParser};
-use crate::{macros::single_parser, parser::PartDateCode};
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::oxy_u4::unknown().parse("AKV 522").is_ok());
-/// ```
-pub fn unknown() -> &'static impl LabelParser<GenericPart> {
-    single_parser!(GenericPart, r#"^AKV\ ([0-9])([0-9]{2})$"#, move |c| {
-        Ok(GenericPart {
-            kind: "AKV".to_owned(),
-            manufacturer: None,
-            date_code: Some(PartDateCode::YearWeek {
-                year: year1(&c[1])?,
-                week: week2(&c[2])?,
-            }),
-        })
-    })
-}
-
-pub fn oxy_u4() -> &'static impl LabelParser<GenericPart> {
-    unknown()
-}
diff --git a/model/src/parser/oxy_u5.rs b/model/src/parser/oxy_u5.rs
deleted file mode 100644
index 348df3ece..000000000
--- a/model/src/parser/oxy_u5.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{week2, year2, LabelParser};
-use crate::{
-    macros::single_parser,
-    parser::{GenericPart, PartDateCode},
-};
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::oxy_u5::unknown().parse("CP6465 B 02 KOR0531 635963").is_ok());
-/// ```
-pub fn unknown() -> &'static impl LabelParser<GenericPart> {
-    single_parser!(
-        GenericPart,
-        r#"^CP6465\ B\ 0[0-9]\ KOR([0-9]{2})([0-9]{2})\ [0-9]{6}$"#,
-        move |c| {
-            Ok(GenericPart {
-                kind: "CP6465".to_owned(),
-                manufacturer: None,
-                date_code: Some(PartDateCode::YearWeek {
-                    year: year2(&c[1])?,
-                    week: week2(&c[2])?,
-                }),
-            })
-        },
-    )
-}
-
-pub fn oxy_u5() -> &'static impl LabelParser<GenericPart> {
-    unknown()
-}
diff --git a/model/src/parser/rohm.rs b/model/src/parser/rohm.rs
index d1a8ef0c0..caf4e7ecc 100644
--- a/model/src/parser/rohm.rs
+++ b/model/src/parser/rohm.rs
@@ -12,8 +12,8 @@ use nom::{
 };
 
 use super::{
-    for_nom::{alnum_uppers, digits, month1_123abc, year1, year1_week2},
-    Eeprom, GenericPart, Manufacturer, NomParser, PartDateCode,
+    for_nom::{alnum_uppers, digits, lines2, month1_123abc, year1, year1_week2},
+    GenericPart, Manufacturer, NomParser, PartDateCode,
 };
 
 /// ROHM ??9853 EEPROM (SOP-8)
@@ -23,11 +23,11 @@ use super::{
 /// assert!(parser::rohm::ROHM_9853.parse("9853 2A46").is_ok());
 /// assert!(parser::rohm::ROHM_9853.parse("9853 6912").is_ok());
 /// ```
-pub static ROHM_9853: NomParser<Eeprom> = NomParser {
+pub static ROHM_9853: NomParser<GenericPart> = NomParser {
     name: "ROHM 9853",
     f: |input| {
-        tuple((tag("9853"), char(' '), year1, month1_123abc, digits(2)))
-            .map(|(kind, _, year, month, _)| Eeprom {
+        lines2(tag("9853"), tuple((year1, month1_123abc, digits(2))))
+            .map(|(kind, (year, month, _))| GenericPart {
                 kind: String::from(kind),
                 manufacturer: Some(Manufacturer::Rohm),
                 date_code: Some(PartDateCode::YearMonth { year, month }),
@@ -42,18 +42,14 @@ pub static ROHM_9853: NomParser<Eeprom> = NomParser {
 /// use gbhwdb_model::parser::{self, LabelParser};
 /// assert!(parser::rohm::ROHM_9854.parse("9854 5S95W").is_ok());
 /// ```
-pub static ROHM_9854: NomParser<Eeprom> = NomParser {
+pub static ROHM_9854: NomParser<GenericPart> = NomParser {
     name: "ROHM 9854",
     f: |input| {
-        tuple((
+        lines2(
             tag("9854"),
-            char(' '),
-            year1,
-            alnum_uppers(1),
-            digits(2),
-            char('W'),
-        ))
-        .map(|(kind, _, year, _, _, _)| Eeprom {
+            tuple((year1, alnum_uppers(1), digits(2), char('W'))),
+        )
+        .map(|(kind, (year, _, _, _))| GenericPart {
             kind: String::from(kind),
             manufacturer: Some(Manufacturer::Rohm),
             date_code: Some(PartDateCode::Year { year }),
diff --git a/model/src/parser/sgb_rom.rs b/model/src/parser/sgb_rom.rs
deleted file mode 100644
index 4429dc5fc..000000000
--- a/model/src/parser/sgb_rom.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-// SPDX-FileCopyrightText: 2017-2023 Joonas Javanainen <joonas.javanainen@gmail.com>
-//
-// SPDX-License-Identifier: MIT
-
-use super::{week2, year2, LabelParser};
-use crate::{
-    macros::{multi_parser, single_parser},
-    parser::{fujitsu, nec, oki, sharp, toshiba, MaskRom, PartDateCode},
-};
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::sgb_rom::unknown2().parse("SYS-SGB-2 © 1994 Nintendo 9423 E").is_ok());
-/// ```
-pub fn unknown2() -> &'static impl LabelParser<MaskRom> {
-    single_parser!(
-        MaskRom,
-        r#"^(SYS-SGB-(NT|2))\ ©\ 1994\ Nintendo\ ([0-9]{2})([0-9]{2})\ [A-Z]$"#,
-        move |c| {
-            Ok(MaskRom {
-                rom_id: c[1].to_owned(),
-                manufacturer: None,
-                chip_type: None,
-                mask_code: None,
-                date_code: Some(PartDateCode::YearWeek {
-                    year: year2(&c[3])?,
-                    week: week2(&c[4])?,
-                }),
-            })
-        },
-    )
-}
-
-/// ```
-/// use gbhwdb_model::parser::{self, LabelParser};
-/// assert!(parser::sgb_rom::unknown3().parse("SYS-SGB-2 JAPAN © 1994 Nintendo 427A2 A04 NND").is_ok());
-/// ```
-pub fn unknown3() -> &'static impl LabelParser<MaskRom> {
-    single_parser!(
-        MaskRom,
-        r#"^(SYS-SGB-(NT|2))\ JAPAN\ ©\ 1994\ Nintendo\ [[:alnum:]]{5}\ [[:alnum:]]{3}\ [A-Z]{3}$"#,
-        move |c| {
-            Ok(MaskRom {
-                rom_id: c[1].to_owned(),
-                manufacturer: None,
-                chip_type: None,
-                mask_code: None,
-                date_code: None,
-            })
-        },
-    )
-}
-
-pub fn sgb_rom() -> &'static impl LabelParser<MaskRom> {
-    multi_parser!(
-        MaskRom,
-        &toshiba::TOSHIBA_SGB_ROM,
-        &sharp::SHARP_SGB_ROM,
-        &sharp::SHARP_SGB2_ROM,
-        &oki::OKI_SGB_ROM,
-        &fujitsu::FUJITSU_SGB_ROM,
-        unknown2(),
-        unknown3(),
-        &nec::NEC_SGB_ROM,
-    )
-}
diff --git a/model/src/parser/stamp.rs b/model/src/parser/stamp.rs
new file mode 100644
index 000000000..3852d1d8c
--- /dev/null
+++ b/model/src/parser/stamp.rs
@@ -0,0 +1,71 @@
+// SPDX-FileCopyrightText: Joonas Javanainen <joonas.javanainen@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+use nom::{character::complete::one_of, combinator::opt, sequence::terminated, Parser as _};
+
+use super::{
+    for_nom::{month2, satisfy_m_n_complete, week2, year1},
+    NomParser, Year,
+};
+use crate::time::{Month, Week};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DmgStamp {
+    pub year: Option<Year>,
+    pub month: Option<Month>,
+}
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::stamp::DMG_STAMP.parse("010 23").is_ok());
+/// assert!(parser::stamp::DMG_STAMP.parse("903-22").is_ok());
+/// assert!(parser::stamp::DMG_STAMP.parse("709.3901").is_ok());
+/// assert!(parser::stamp::DMG_STAMP.parse("202-0007").is_ok());
+/// assert!(parser::stamp::DMG_STAMP.parse("008.270-").is_ok());
+/// ```
+pub static DMG_STAMP: NomParser<DmgStamp> = NomParser {
+    name: "DMG stamp",
+    f: |input| {
+        terminated(
+            year1.and(month2),
+            opt(one_of("- ."))
+                .and(satisfy_m_n_complete(2, 4, |c| {
+                    c.is_ascii_digit() || c == '-'
+                }))
+                .and(opt(nom::character::complete::char('Y'))),
+        )
+        .map(|(year, month)| DmgStamp {
+            year: Some(year),
+            month: Some(month),
+        })
+        .parse(input)
+    },
+};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct CgbStamp {
+    pub year: Option<Year>,
+    pub week: Option<Week>,
+}
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::stamp::CGB_STAMP.parse("218-2221").is_ok());
+/// ```
+pub static CGB_STAMP: NomParser<CgbStamp> = NomParser {
+    name: "CGB stamp",
+    f: |input| {
+        terminated(
+            week2.and(year1),
+            opt(one_of("- .X"))
+                .and(satisfy_m_n_complete(2, 4, |c| c.is_ascii_digit()))
+                .and(opt(nom::character::complete::char('Y'))),
+        )
+        .map(|(week, year)| CgbStamp {
+            year: Some(year),
+            week: Some(week),
+        })
+        .parse(input)
+    },
+};
diff --git a/model/src/parser/tdk.rs b/model/src/parser/tdk.rs
new file mode 100644
index 000000000..0d5cf6e3d
--- /dev/null
+++ b/model/src/parser/tdk.rs
@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: Joonas Javanainen <joonas.javanainen@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+use nom::{bytes::streaming::tag, Parser};
+
+use super::{
+    for_nom::{alphas, lines3, uppers},
+    GenericPart, Manufacturer, NomParser,
+};
+
+/// TDK ZJY-M4A
+///
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::tdk::TDK_ZJY_M4A.parse("TDK ZJY-M4A N").is_ok());
+/// ```
+pub static TDK_ZJY_M4A: NomParser<GenericPart> = NomParser {
+    name: "TDK ZJY-M4A",
+    f: |input| {
+        lines3(tag("TDK"), tag("ZJY-M4A"), uppers(1))
+            .map(|(_, kind, _)| GenericPart {
+                kind: String::from(kind),
+                manufacturer: Some(Manufacturer::Tdk),
+                date_code: None,
+            })
+            .parse(input)
+    },
+};
+
+/// TDK ZJY-M4PA
+///
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::tdk::TDK_ZJY_M4PA.parse("TDK ZJY-M4PA n").is_ok());
+/// ```
+pub static TDK_ZJY_M4PA: NomParser<GenericPart> = NomParser {
+    name: "TDK ZJY-M4PA",
+    f: |input| {
+        lines3(tag("TDK"), tag("ZJY-M4PA"), alphas(1))
+            .map(|(_, kind, _)| GenericPart {
+                kind: String::from(kind),
+                manufacturer: Some(Manufacturer::Tdk),
+                date_code: None,
+            })
+            .parse(input)
+    },
+};
diff --git a/model/src/parser/unknown.rs b/model/src/parser/unknown.rs
new file mode 100644
index 000000000..a3ebc18c1
--- /dev/null
+++ b/model/src/parser/unknown.rs
@@ -0,0 +1,216 @@
+// SPDX-FileCopyrightText: Joonas Javanainen <joonas.javanainen@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+use nom::{
+    branch::alt,
+    bytes::streaming::tag,
+    character::streaming::char,
+    combinator::opt,
+    sequence::{preceded, separated_pair, tuple},
+    Parser,
+};
+
+use super::{
+    for_nom::{
+        alnum_uppers, digits, lines2, lines3, lines4, uppers, year1, year1_week2, year2_week2,
+    },
+    Crystal, GenericPart, MaskRom, NomParser, PartDateCode,
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_SGB_ROM.parse("SYS-SGB-2 JAPAN © 1994 Nintendo 427A2 A04 NND").is_ok());
+/// assert!(parser::unknown::UNKNOWN_SGB_ROM.parse("SYS-SGB-2 © 1994 Nintendo 9423 E").is_ok());
+/// ```
+pub static UNKNOWN_SGB_ROM: NomParser<MaskRom> = NomParser {
+    name: "Unknown SGB ROM",
+    f: |input| {
+        alt((
+            lines3(
+                separated_pair(tag("SYS-SGB-2"), char(' '), tag("JAPAN")),
+                tag("© 1994 Nintendo"),
+                tuple((
+                    alnum_uppers(5),
+                    char(' '),
+                    alnum_uppers(3),
+                    char(' '),
+                    uppers(3),
+                )),
+            )
+            .map(|((rom_id, _), _, _)| MaskRom {
+                rom_id: String::from(rom_id),
+                manufacturer: None,
+                chip_type: None,
+                mask_code: None,
+                date_code: None,
+            }),
+            lines3(
+                tag("SYS-SGB-2"),
+                tag("© 1994 Nintendo"),
+                separated_pair(year2_week2, char(' '), uppers(1)),
+            )
+            .map(|(rom_id, _, (date_code, _))| MaskRom {
+                rom_id: String::from(rom_id),
+                manufacturer: None,
+                chip_type: None,
+                mask_code: None,
+                date_code: Some(date_code),
+            }),
+        ))
+        .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_LCS5_EEPROM.parse("LCS5 040").is_ok());
+/// assert!(parser::unknown::UNKNOWN_LCS5_EEPROM.parse("LCS5 435 09").is_ok());
+/// ```
+pub static UNKNOWN_LCS5_EEPROM: NomParser<GenericPart> = NomParser {
+    name: "Unknown LCS5 EEPROM",
+    f: |input| {
+        tuple((
+            tag("LCS5 "),
+            year1_week2,
+            opt(tuple((nom::character::complete::char(' '), digits(2)))),
+        ))
+        .map(|(_, date_code, _)| GenericPart {
+            kind: "LC56".to_owned(),
+            manufacturer: None,
+            date_code: Some(date_code),
+        })
+        .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_LC56_EEPROM.parse("LC56 W617 08").is_ok());
+/// ```
+pub static UNKNOWN_LC56_EEPROM: NomParser<GenericPart> = NomParser {
+    name: "Unknown LC56 EEPROM",
+    f: |input| {
+        lines3(tag("LC56"), uppers(1).and(digits(3)), digits(2))
+            .map(|(_, _, _)| GenericPart {
+                kind: "LC56".to_owned(),
+                manufacturer: None,
+                date_code: None,
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_AGS_CHARGE_CONTROLLER.parse("2253B 3129").is_ok());
+/// ```
+pub static UNKNOWN_AGS_CHARGE_CONTROLLER: NomParser<GenericPart> = NomParser {
+    name: "Unknown AGS charge controller",
+    f: |input| {
+        lines2(tag("2253B"), tuple((digits(1), alnum_uppers(1), digits(2))))
+            .map(|(kind, _)| GenericPart {
+                kind: String::from(kind),
+                manufacturer: None,
+                date_code: None,
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_CRYSTAL_32_KIHZ.parse("32K09").is_ok());
+/// assert!(parser::unknown::UNKNOWN_CRYSTAL_32_KIHZ.parse("32K0Z").is_ok());
+/// ```
+pub static UNKNOWN_CRYSTAL_32_KIHZ: NomParser<Crystal> = NomParser {
+    name: "Unknown crystal, 32 KiHz",
+    f: |input| {
+        tag("32K")
+            .and(year1.and(alnum_uppers(1)))
+            .map(|(_, (year, _))| Crystal {
+                manufacturer: None,
+                frequency: Crystal::FREQ_32_KIHZ,
+                date_code: Some(PartDateCode::Year { year }),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_DMG_CRYSTAL_4_MIHZ.parse("4.19C59").is_ok());
+/// ```
+pub static UNKNOWN_DMG_CRYSTAL_4_MIHZ: NomParser<Crystal> = NomParser {
+    name: "Unknown DMG crystal, 4 MiHz",
+    f: |input| {
+        tag("4.19C")
+            .and(year1.and(alnum_uppers(1)))
+            .map(|(_, (year, _))| Crystal {
+                manufacturer: None,
+                frequency: Crystal::FREQ_4_MIHZ,
+                date_code: Some(PartDateCode::Year { year }),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_MGB_CRYSTAL_4_MIHZ.parse("4.1943 RVR 841").is_ok());
+/// assert!(parser::unknown::UNKNOWN_MGB_CRYSTAL_4_MIHZ.parse("4.1943 9752").is_ok());
+/// ```
+pub static UNKNOWN_MGB_CRYSTAL_4_MIHZ: NomParser<Crystal> = NomParser {
+    name: "Unknown MGB crystal, 4 MiHz",
+    f: |input| {
+        lines2(
+            tag("4.1943"),
+            alt((preceded(tag("RVR "), year1_week2), year2_week2)),
+        )
+        .map(|(_, date_code)| Crystal {
+            manufacturer: None,
+            frequency: Crystal::FREQ_4_MIHZ,
+            date_code: Some(date_code),
+        })
+        .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_OXY_U4.parse("AKV 522").is_ok());
+/// ```
+pub static UNKNOWN_OXY_U4: NomParser<GenericPart> = NomParser {
+    name: "Unknown OXY U4",
+    f: |input| {
+        lines2(tag("AKV"), year1_week2)
+            .map(|(kind, date_code)| GenericPart {
+                kind: String::from(kind),
+                manufacturer: None,
+                date_code: Some(date_code),
+            })
+            .parse(input)
+    },
+};
+
+/// ```
+/// use gbhwdb_model::parser::{self, LabelParser};
+/// assert!(parser::unknown::UNKNOWN_OXY_U5.parse("CP6465 B 02 KOR0531 635963").is_ok());
+/// ```
+pub static UNKNOWN_OXY_U5: NomParser<GenericPart> = NomParser {
+    name: "Unknown OXY U5",
+    f: |input| {
+        lines4(
+            tag("CP6465"),
+            separated_pair(tag("B"), char(' '), char('0').and(digits(1))),
+            preceded(tag("KOR"), year2_week2),
+            digits(6),
+        )
+        .map(|(kind, _, date_code, _)| GenericPart {
+            kind: String::from(kind),
+            manufacturer: None,
+            date_code: Some(date_code),
+        })
+        .parse(input)
+    },
+};
diff --git a/site/src/main.rs b/site/src/main.rs
index c9c921e7d..7cc3c24cd 100644
--- a/site/src/main.rs
+++ b/site/src/main.rs
@@ -441,11 +441,7 @@ fn read_dmg_submissions() -> Result<Vec<LegacyDmgSubmission>, Error> {
                         ..ProcessedPart::default()
                     })
             });
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.x1,
-                parser::crystal_4mihz::crystal_4mihz(),
-            );
+            let crystal = map_part(year_hint, &console.mainboard.x1, parser::dmg_crystal());
 
             let mainboard = LegacyDmgMainboard {
                 kind: console.mainboard.label.clone(),
@@ -503,7 +499,7 @@ fn read_dmg_submissions() -> Result<Vec<LegacyDmgSubmission>, Error> {
                 .as_ref()
                 .filter(|_| !console.mainboard.outlier)
                 .map(|stamp| {
-                    gbhwdb_model::parser::dmg_stamp::dmg_stamp()
+                    gbhwdb_model::parser::dmg_stamp()
                         .parse(stamp)
                         .unwrap_or_else(|_| panic!("{}", stamp))
                 });
@@ -512,7 +508,7 @@ fn read_dmg_submissions() -> Result<Vec<LegacyDmgSubmission>, Error> {
                 .as_ref()
                 .and_then(|board| board.stamp.as_ref().filter(|_| !board.outlier))
                 .map(|stamp| {
-                    gbhwdb_model::parser::dmg_stamp::dmg_stamp()
+                    gbhwdb_model::parser::dmg_stamp()
                         .parse(stamp)
                         .unwrap_or_else(|_| panic!("{}", stamp))
                 });
@@ -623,7 +619,7 @@ fn read_sgb_submissions() -> Result<Vec<LegacySgbSubmission>, Error> {
                 &console.mainboard.u4,
                 parser::sram::sram_sop_28_5v(),
             );
-            let rom = map_part(year_hint, &console.mainboard.u5, parser::sgb_rom::sgb_rom());
+            let rom = map_part(year_hint, &console.mainboard.u5, parser::sgb_rom());
             let cic = map_part(year_hint, &console.mainboard.u6, parser::cic());
             let mainboard = LegacySgbMainboard {
                 kind: console.mainboard.label.clone(),
@@ -695,11 +691,7 @@ fn read_mgb_submissions() -> Result<Vec<LegacyMgbSubmission>, Error> {
             );
             let amplifier = map_part(year_hint, &console.mainboard.u3, parser::mgb_amp());
             let regulator = map_part(year_hint, &console.mainboard.u4, parser::dmg_reg());
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.x1,
-                parser::crystal_4mihz::crystal_4mihz(),
-            );
+            let crystal = map_part(year_hint, &console.mainboard.x1, parser::mgb_crystal());
             let mainboard = LegacyMgbMainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
@@ -717,7 +709,7 @@ fn read_mgb_submissions() -> Result<Vec<LegacyMgbSubmission>, Error> {
             let lcd_panel = to_legacy_lcd_panel(year_hint, &console.screen);
 
             let stamp = console.mainboard.stamp.as_ref().map(|stamp| {
-                gbhwdb_model::parser::dmg_stamp::dmg_stamp()
+                gbhwdb_model::parser::dmg_stamp()
                     .parse(stamp)
                     .unwrap_or_else(|_| panic!("{}", stamp))
             });
@@ -788,11 +780,7 @@ fn read_mgl_submissions() -> Result<Vec<LegacyMglSubmission>, Error> {
             );
             let amplifier = map_part(year_hint, &console.mainboard.u3, parser::mgb_amp());
             let regulator = map_part(year_hint, &console.mainboard.u4, parser::dmg_reg());
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.x1,
-                parser::crystal_4mihz::crystal_4mihz(),
-            );
+            let crystal = map_part(year_hint, &console.mainboard.x1, parser::mgb_crystal());
             let t1 = map_part(year_hint, &console.mainboard.t1, parser::mgl_transformer());
             let mainboard = LegacyMglMainboard {
                 kind: console.mainboard.label.clone(),
@@ -812,7 +800,7 @@ fn read_mgl_submissions() -> Result<Vec<LegacyMglSubmission>, Error> {
             let lcd_panel = to_legacy_lcd_panel(year_hint, &console.screen);
 
             let stamp = console.mainboard.stamp.as_ref().map(|stamp| {
-                gbhwdb_model::parser::cgb_stamp::cgb_stamp()
+                gbhwdb_model::parser::cgb_stamp()
                     .parse(stamp)
                     .unwrap_or_else(|_| panic!("{}", stamp))
             });
@@ -878,14 +866,10 @@ fn read_sgb2_submissions() -> Result<Vec<LegacySgb2Submission>, Error> {
                 &console.mainboard.u3,
                 parser::sram::sram_sop_28_5v(),
             );
-            let rom = map_part(year_hint, &console.mainboard.u4, parser::sgb_rom::sgb_rom());
+            let rom = map_part(year_hint, &console.mainboard.u4, parser::sgb2_rom());
             let cic = map_part(year_hint, &console.mainboard.u5, parser::cic());
-            let coil = map_part(year_hint, &console.mainboard.coil1, parser::coil::coil());
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.xtal1,
-                parser::crystal_20mihz::crystal_20mihz(),
-            );
+            let coil = map_part(year_hint, &console.mainboard.coil1, parser::sgb2_coil());
+            let crystal = map_part(year_hint, &console.mainboard.xtal1, parser::sgb2_crystal());
             let mainboard = LegacySgb2Mainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
@@ -968,11 +952,7 @@ fn read_cgb_submissions() -> Result<Vec<LegacyCgbSubmission>, Error> {
             );
             let amplifier = map_part(year_hint, &console.mainboard.u3, parser::mgb_amp());
             let regulator = map_part(year_hint, &console.mainboard.u4, parser::cgb_reg());
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.x1,
-                parser::crystal_8mihz::crystal_8mihz(),
-            );
+            let crystal = map_part(year_hint, &console.mainboard.x1, parser::cgb_crystal());
             let mainboard = LegacyCgbMainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
@@ -993,7 +973,7 @@ fn read_cgb_submissions() -> Result<Vec<LegacyCgbSubmission>, Error> {
                     if stamp.starts_with(&['6', '7', '8', '9'][..]) {
                         (
                             Some(
-                                gbhwdb_model::parser::dmg_stamp::dmg_stamp()
+                                gbhwdb_model::parser::dmg_stamp()
                                     .parse(stamp)
                                     .unwrap_or_else(|_| panic!("{}", stamp)),
                             ),
@@ -1003,7 +983,7 @@ fn read_cgb_submissions() -> Result<Vec<LegacyCgbSubmission>, Error> {
                         (
                             None,
                             Some(
-                                gbhwdb_model::parser::cgb_stamp::cgb_stamp()
+                                gbhwdb_model::parser::cgb_stamp()
                                     .parse(stamp)
                                     .unwrap_or_else(|_| panic!("{}", stamp)),
                             ),
@@ -1082,11 +1062,7 @@ fn read_agb_submissions() -> Result<Vec<LegacyAgbSubmission>, Error> {
             let regulator = map_part(year_hint, &console.mainboard.u3, parser::agb_reg());
             let u4 = map_part(year_hint, &console.mainboard.u4, parser::agb_pmic());
             let amplifier = map_part(year_hint, &console.mainboard.u6, parser::agb_amp());
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.x1,
-                parser::crystal_4mihz::crystal_4mihz(),
-            );
+            let crystal = map_part(year_hint, &console.mainboard.x1, parser::agb_crystal());
             let mainboard = LegacyAgbMainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
@@ -1103,7 +1079,7 @@ fn read_agb_submissions() -> Result<Vec<LegacyAgbSubmission>, Error> {
             };
 
             let stamp = console.mainboard.stamp.as_ref().map(|stamp| {
-                gbhwdb_model::parser::cgb_stamp::cgb_stamp()
+                gbhwdb_model::parser::cgb_stamp()
                     .parse(stamp)
                     .unwrap_or_else(|_| panic!("{}", stamp))
             });
@@ -1178,16 +1154,8 @@ fn read_ags_submissions() -> Result<Vec<LegacyAgsSubmission>, Error> {
                 _ => map_part(year_hint, &console.mainboard.u3, parser::agb_amp()),
             };
             let u4 = map_part(year_hint, &console.mainboard.u4, parser::ags_pmic_old());
-            let u5 = map_part(
-                year_hint,
-                &console.mainboard.u5,
-                parser::ags_charge_ctrl::ags_charge_ctrl(),
-            );
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.x1,
-                parser::crystal_4mihz::crystal_4mihz(),
-            );
+            let u5 = map_part(year_hint, &console.mainboard.u5, parser::ags_charge_ctrl());
+            let crystal = map_part(year_hint, &console.mainboard.x1, parser::ags_crystal());
             let mainboard = LegacyAgsMainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
@@ -1263,11 +1231,7 @@ fn read_gbs_submissions() -> Result<Vec<LegacyGbsSubmission>, Error> {
             let u4 = map_part(year_hint, &console.mainboard.u4, parser::gbs_dol());
             let u5 = map_part(year_hint, &console.mainboard.u5, parser::gbs_reg());
             let u6 = map_part(year_hint, &console.mainboard.u6, parser::gbs_reg());
-            let crystal = map_part(
-                year_hint,
-                &console.mainboard.y1,
-                parser::crystal_32mihz::crystal_32mihz(),
-            );
+            let crystal = map_part(year_hint, &console.mainboard.y1, parser::gbs_crystal());
             let mainboard = LegacyGbsMainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
@@ -1286,7 +1250,7 @@ fn read_gbs_submissions() -> Result<Vec<LegacyGbsSubmission>, Error> {
             };
 
             let stamp = console.mainboard.stamp.as_ref().map(|stamp| {
-                gbhwdb_model::parser::cgb_stamp::cgb_stamp()
+                gbhwdb_model::parser::cgb_stamp()
                     .parse(stamp)
                     .unwrap_or_else(|_| panic!("{}", stamp))
             });
@@ -1345,8 +1309,8 @@ fn read_oxy_submissions() -> Result<Vec<LegacyOxySubmission>, Error> {
             let year_hint = console.mainboard.year.or(Some(2005));
             let cpu = map_part(year_hint, &console.mainboard.u1, parser::agb_soc_bga());
             let u2 = map_part(year_hint, &console.mainboard.u2, parser::oxy_pmic());
-            let u4 = map_part(year_hint, &console.mainboard.u4, parser::oxy_u4::oxy_u4());
-            let u5 = map_part(year_hint, &console.mainboard.u5, parser::oxy_u5::oxy_u5());
+            let u4 = map_part(year_hint, &console.mainboard.u4, parser::oxy_u4());
+            let u5 = map_part(year_hint, &console.mainboard.u5, parser::oxy_u5());
             let mainboard = LegacyOxyMainboard {
                 kind: console.mainboard.label.clone(),
                 circled_letters: console.mainboard.circled_letters.clone(),
diff --git a/site/src/process/part.rs b/site/src/process/part.rs
index 135f11a5f..71f298a9f 100644
--- a/site/src/process/part.rs
+++ b/site/src/process/part.rs
@@ -8,7 +8,7 @@ use gbhwdb_model::{
     parser::{self, LabelParser, Manufacturer, PartDateCode},
 };
 
-use crate::{process::to_full_year, process::DateCode};
+use crate::process::DateCode;
 
 #[derive(Clone, Debug, Eq, PartialEq, Default)]
 pub struct ProcessedPart {
@@ -70,23 +70,7 @@ impl ParsedPart for parser::Crystal {
             label: Some(label),
             kind: Some(self.format_frequency()),
             manufacturer: self.manufacturer,
-            date_code: DateCode {
-                year: to_full_year(year_hint, self.year),
-                week: self.week,
-                month: self.month,
-                ..DateCode::default()
-            },
-            ..ProcessedPart::default()
-        }
-    }
-}
-
-impl ParsedPart for parser::Coil {
-    fn process(self, _: Option<u16>, label: String) -> ProcessedPart {
-        ProcessedPart {
-            label: Some(label),
-            kind: Some(self.kind),
-            manufacturer: self.manufacturer,
+            date_code: loose_datecode(year_hint, self.date_code),
             ..ProcessedPart::default()
         }
     }