diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 58adcfc..85de526 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -4,13 +4,17 @@
 
 mod fmt;
 pub mod parser;
-use crate::{library::AttributeType, ArcStr};
-use core::hash::{BuildHasher as _, Hash, Hasher as _};
-use core::{fmt::Write, num::ParseIntError, str::FromStr};
+use crate::{common::f64_into_hash_ord_fn, library::AttributeType, ArcStr};
+use core::{
+  cmp::Ordering,
+  fmt::Write,
+  hash::{BuildHasher as _, Hash as _, Hasher as _},
+  num::ParseIntError,
+  str::FromStr,
+};
 pub use fmt::{CodeFormatter, DefaultCodeFormatter, DefaultIndentation, Indentation};
 use itertools::{izip, Itertools as _};
 use nom::{error::Error, IResult};
-use ordered_float::NotNan;
 use std::collections::HashMap;
 const DEFINED_COMMENT: &str = " /* user defined attribute */";
 
@@ -83,13 +87,13 @@ pub struct GroupWrapper {
 }
 impl Ord for GroupWrapper {
   #[inline]
-  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+  fn cmp(&self, other: &Self) -> Ordering {
     self.title.cmp(&other.title)
   }
 }
 impl PartialOrd for GroupWrapper {
   #[inline]
-  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
     Some(self.cmp(other))
   }
 }
@@ -135,9 +139,7 @@ impl PartialEq for SimpleDefined {
       (Self::Float(l0), Self::Float(r0)) => {
         l0.len() == r0.len()
           && izip!(l0, r0).all(|lr| match lr {
-            (Ok(l), Ok(r)) => unsafe {
-              NotNan::new_unchecked(*l) == NotNan::new_unchecked(*r)
-            },
+            (Ok(l), Ok(r)) => f64_into_hash_ord_fn(l) == f64_into_hash_ord_fn(r),
             (Err(l), Err(r)) => l == r,
             _ => false,
           })
@@ -149,39 +151,37 @@ impl PartialEq for SimpleDefined {
 impl Eq for SimpleDefined {}
 impl PartialOrd for SimpleDefined {
   #[inline]
-  fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
     Some(self.cmp(other))
   }
 }
 impl Ord for SimpleDefined {
   #[inline]
-  fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+  fn cmp(&self, other: &Self) -> Ordering {
     match (self, other) {
-      (SimpleDefined::Boolean(l), SimpleDefined::Boolean(r)) => l.cmp(r),
-      (SimpleDefined::String(l), SimpleDefined::String(r)) => l.cmp(r),
-      (SimpleDefined::Integer(l), SimpleDefined::Integer(r)) => l.cmp(r),
-      (SimpleDefined::Float(l), SimpleDefined::Float(r)) => match l.len().cmp(&r.len()) {
-        std::cmp::Ordering::Less => std::cmp::Ordering::Less,
-        std::cmp::Ordering::Greater => std::cmp::Ordering::Greater,
-        std::cmp::Ordering::Equal => l
+      (Self::Boolean(l), Self::Boolean(r)) => l.cmp(r),
+      (Self::String(l), Self::String(r)) => l.cmp(r),
+      (Self::Integer(l), Self::Integer(r)) => l.cmp(r),
+      (Self::Float(l), Self::Float(r)) => match l.len().cmp(&r.len()) {
+        Ordering::Less => Ordering::Less,
+        Ordering::Greater => Ordering::Greater,
+        Ordering::Equal => l
           .iter()
           .map(|res| match res {
-            Ok(f) => Ok(unsafe { NotNan::new_unchecked(*f) }),
+            Ok(f) => Ok(f64_into_hash_ord_fn(f)),
             Err(s) => Err(s),
           })
           .cmp(r.iter().map(|res| match res {
-            Ok(f) => Ok(unsafe { NotNan::new_unchecked(*f) }),
+            Ok(f) => Ok(f64_into_hash_ord_fn(f)),
             Err(s) => Err(s),
           })),
       },
-      (SimpleDefined::Boolean(_), _) => std::cmp::Ordering::Less,
-      (_, SimpleDefined::Boolean(_)) => std::cmp::Ordering::Greater,
-      (_, SimpleDefined::Float(_)) => std::cmp::Ordering::Less,
-      (SimpleDefined::Float(_), _) => std::cmp::Ordering::Greater,
-      (SimpleDefined::String(_), SimpleDefined::Integer(_)) => std::cmp::Ordering::Less,
-      (SimpleDefined::Integer(_), SimpleDefined::String(_)) => {
-        std::cmp::Ordering::Greater
-      }
+      (Self::Boolean(_), _)
+      | (_, Self::Float(_))
+      | (Self::String(_), Self::Integer(_)) => Ordering::Less,
+      (Self::Float(_), _)
+      | (_, Self::Boolean(_))
+      | (Self::Integer(_), Self::String(_)) => Ordering::Greater,
     }
   }
 }
diff --git a/src/ast/parser.rs b/src/ast/parser.rs
index a93f5c6..57ae84a 100644
--- a/src/ast/parser.rs
+++ b/src/ast/parser.rs
@@ -363,7 +363,7 @@ pub(crate) fn simple<'a>(
 }
 #[inline]
 pub(crate) fn float_one(i: &str) -> IResult<&str, f64, Error<&str>> {
-  #[expect(clippy::string_slice, clippy::undocumented_unsafe_blocks)]
+  #[expect(clippy::string_slice)]
   match fast_float2::parse_partial(i) {
     Ok((f, pos)) => Ok((&i[pos..], f)),
     Err(_) => Err(nom::Err::Error(Error::new(i, ErrorKind::Float))),
@@ -388,7 +388,6 @@ fn int_usize(i: &str) -> IResult<&str, usize, Error<&str>> {
 }
 
 #[inline]
-#[expect(clippy::type_complexity)]
 pub(crate) fn complex_id_vector<'a>(
   i: &'a str,
   line_num: &mut usize,
diff --git a/src/cell/items.rs b/src/cell/items.rs
index c6ba3d3..73cf2bc 100644
--- a/src/cell/items.rs
+++ b/src/cell/items.rs
@@ -3,7 +3,10 @@ use crate::{
     join_fmt, CodeFormatter, ComplexAttri, ComplexParseError, GroupComments, GroupFn,
     GroupSet, Indentation, NamedGroup, ParseScope, SimpleAttri, SimpleParseRes,
   },
-  common::{items::WordSet, table::CompactCcsPower},
+  common::{
+    items::{NameList, WordSet},
+    table::CompactCcsPower,
+  },
   expression::{logic, LogicBooleanExpression, PowerGroundBooleanExpression},
   pin::Direction,
   timing::items::Mode,
@@ -46,10 +49,14 @@ pub struct LeakagePower<C: Ctx> {
   #[size = 8]
   #[liberty(simple(type = Option))]
   pub power_level: Option<ArcStr>,
-  #[id]
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 64]
   #[liberty(simple)]
-  pub related_pg_pin: WordSet,
+  pub related_pg_pin: NameList,
   #[id(
     borrow = "Option<&LogicBooleanExpression>",
     check_fn = "mut_set::borrow_option!",
@@ -502,14 +509,22 @@ pub struct DynamicCurrent<C: Ctx> {
   #[size = 80]
   #[liberty(simple(type = Option))]
   pub when: Option<LogicBooleanExpression>,
-  #[id]
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 64]
   #[liberty(simple)]
-  pub related_inputs: WordSet,
-  #[id]
+  pub related_inputs: NameList,
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 64]
   #[liberty(simple)]
-  pub related_outputs: WordSet,
+  pub related_outputs: NameList,
   #[size = 24]
   #[liberty(complex(type = Option))]
   pub typical_capacitances: Option<Vec<f64>>,
diff --git a/src/common/impls.rs b/src/common/impls.rs
index dc603d2..7fe44fb 100644
--- a/src/common/impls.rs
+++ b/src/common/impls.rs
@@ -8,7 +8,10 @@ use crate::{
   },
   ArcStr,
 };
-use core::fmt::{self, Write};
+use core::{
+  fmt::{self, Write},
+  str::FromStr,
+};
 use itertools::Itertools as _;
 
 use super::{
@@ -18,7 +21,6 @@ use super::{
 crate::ast::impl_self_builder!(f64);
 impl SimpleAttri for f64 {
   #[inline]
-  #[expect(clippy::undocumented_unsafe_blocks)]
   fn nom_parse<'a>(i: &'a str, scope: &mut ParseScope) -> ast::SimpleParseRes<'a, Self> {
     ast::parser::simple_custom(i, &mut scope.line_num, ast::parser::float_one)
   }
@@ -117,8 +119,7 @@ impl NameAttri for ArcStr {
 impl NameAttri for NameList {
   #[inline]
   fn parse(v: Vec<&str>) -> Result<Self, IdError> {
-    let l = v.len();
-    match l {
+    match v.len() {
       0 => Err(IdError::length_dismatch(1, 0, v)),
       #[expect(clippy::indexing_slicing)]
       1 => Ok(Self::Name(v[0].into())),
@@ -133,6 +134,60 @@ impl NameAttri for NameList {
     write!(f, "{self}")
   }
 }
+impl FromStr for NameList {
+  type Err = ();
+  #[inline]
+  #[expect(clippy::unwrap_in_result, clippy::unwrap_used)]
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    let mut v: Vec<_> = s
+      .split(' ')
+      .filter_map(|_s| if _s.is_empty() { None } else { Some(ArcStr::from(_s)) })
+      .collect();
+    match v.len() {
+      0 => Err(()),
+      1 => Ok(Self::Name(v.pop().unwrap())),
+      _ => Ok(Self::List(WordSet { inner: v.into_iter().map(ArcStr::from).collect() })),
+    }
+  }
+}
+crate::ast::impl_self_builder!(NameList);
+impl SimpleAttri for NameList {
+  #[inline]
+  fn nom_parse<'a>(
+    i: &'a str,
+    scope: &mut ParseScope,
+  ) -> ast::SimpleParseRes<'a, Self::Builder> {
+    ast::nom_parse_from_str(i, scope)
+  }
+  #[inline]
+  fn is_set(&self) -> bool {
+    match self {
+      NameList::Name(s) => !s.is_empty(),
+      NameList::List(word_set) => word_set.is_set(),
+    }
+  }
+  #[inline]
+  fn fmt_self<T: Write, I: Indentation>(
+    &self,
+    f: &mut CodeFormatter<'_, T, I>,
+  ) -> fmt::Result {
+    match self {
+      Self::Name(s) => {
+        if is_word(s) {
+          write!(f, "{s}")
+        } else {
+          write!(f, "\"{s}\"")
+        }
+      }
+      Self::List(set) => join_fmt_no_quote(
+        set.inner.iter().sorted(),
+        f,
+        |s, ff| if is_word(s) { write!(ff, "{s}") } else { write!(ff, "\"{s}\"") },
+        " ",
+      ),
+    }
+  }
+}
 
 impl fmt::Display for NameList {
   #[inline]
@@ -263,7 +318,7 @@ impl<const N: usize> ast::ParsingBuilder for [f64; N] {
     builder
   }
 }
-// FIXME
+
 impl<const N: usize> ComplexAttri for [f64; N] {
   #[inline]
   fn parse<'a, I: Iterator<Item = &'a &'a str>>(
diff --git a/src/common/items.rs b/src/common/items.rs
index 4710fad..57346fc 100644
--- a/src/common/items.rs
+++ b/src/common/items.rs
@@ -187,12 +187,10 @@ impl fmt::Display for WordSet {
 impl Ord for WordSet {
   #[inline]
   fn cmp(&self, other: &Self) -> Ordering {
-    if self.inner.is_subset(&other.inner) {
-      Ordering::Less
-    } else if self.inner.is_superset(&other.inner) {
-      Ordering::Greater
-    } else {
-      Ordering::Equal
+    match self.inner.len().cmp(&other.inner.len()) {
+      Ordering::Less => Ordering::Less,
+      Ordering::Greater => Ordering::Greater,
+      Ordering::Equal => self.inner.iter().sorted().cmp(other.inner.iter().sorted()),
     }
   }
 }
@@ -201,14 +199,14 @@ impl Ord for WordSet {
 impl PartialOrd for WordSet {
   #[inline]
   fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    if self.inner.len() == other.inner.len() {
-      self.inner.iter().sorted().partial_cmp(other.inner.iter().sorted())
-    } else if self.inner.is_subset(&other.inner) {
-      Some(Ordering::Less)
-    } else if self.inner.is_superset(&other.inner) {
-      Some(Ordering::Greater)
-    } else {
-      None
+    match self.inner.len().cmp(&other.inner.len()) {
+      Ordering::Less => self.inner.is_subset(&other.inner).then_some(Ordering::Less),
+      Ordering::Greater => {
+        self.inner.is_superset(&other.inner).then_some(Ordering::Greater)
+      }
+      Ordering::Equal => {
+        self.inner.iter().sorted().partial_cmp(other.inner.iter().sorted())
+      }
     }
   }
 }
diff --git a/src/common/mod.rs b/src/common/mod.rs
index 9d583b6..8da25b4 100644
--- a/src/common/mod.rs
+++ b/src/common/mod.rs
@@ -15,6 +15,8 @@ pub(crate) fn parse_f64<S: AsRef<[u8]>>(s: S) -> Result<f64, fast_float2::Error>
   fast_float2::parse(s)
 }
 #[inline]
-pub(crate) fn f64_into_hash_ord_fn(val: &f64) -> NotNan<f64> {
+#[expect(clippy::trivially_copy_pass_by_ref)]
+pub(crate) const fn f64_into_hash_ord_fn(val: &f64) -> NotNan<f64> {
+  // SAFETY: convert float to hash & ord
   unsafe { NotNan::new_unchecked(*val) }
 }
diff --git a/src/common/table.rs b/src/common/table.rs
index 3a0cb91..4679c6d 100644
--- a/src/common/table.rs
+++ b/src/common/table.rs
@@ -112,7 +112,6 @@ pub struct DriverWaveform<C: Ctx> {
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct TableLookUp2D<C: Ctx> {
-  // TODO: unit
   #[size = 8]
   #[liberty(name)]
   #[id(borrow = "Option<&str>", check_fn = "mut_set::borrow_option!", with_ref = false)]
@@ -277,7 +276,6 @@ impl SimpleAttri for VariableTypeCompactLutTemplateIndex3 {
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct Vector3D<C: Ctx> {
-  // TODO: unit
   #[size = 8]
   #[liberty(name)]
   #[id(borrow = "Option<&str>", check_fn = "mut_set::borrow_option!", with_ref = false)]
@@ -315,7 +313,6 @@ pub struct Vector3D<C: Ctx> {
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct ReferenceTimeVector3D<C: Ctx> {
-  // TODO: unit
   #[size = 8]
   #[liberty(name)]
   #[id(borrow = "Option<&str>", check_fn = "mut_set::borrow_option!", with_ref = false)]
@@ -357,7 +354,6 @@ pub struct ReferenceTimeVector3D<C: Ctx> {
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct Vector4D<C: Ctx> {
-  // TODO: unit
   #[size = 8]
   #[liberty(name)]
   #[id(borrow = "Option<&str>", check_fn = "mut_set::borrow_option!", with_ref = false)]
@@ -443,7 +439,6 @@ pub struct Vector4D<C: Ctx> {
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct CompactCcsPower<C: Ctx> {
-  // TODO: unit
   #[size = 8]
   #[liberty(name)]
   #[id(borrow = "Option<&str>", check_fn = "mut_set::borrow_option!", with_ref = false)]
@@ -701,7 +696,6 @@ impl<C: Ctx> GroupFn for CompactCcsPower<C> {}
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct TableLookUp3D<C: Ctx> {
-  // TODO: unit
   #[size = 8]
   #[liberty(name)]
   #[id(borrow = "Option<&str>", check_fn = "mut_set::borrow_option!", with_ref = false)]
@@ -737,7 +731,7 @@ pub struct TableLookUp3D<C: Ctx> {
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct TableLookUp1D<C: Ctx> {
-  // // TODO: unit
+  //
   // unit: (),
   #[size = 8]
   #[liberty(name)]
@@ -774,7 +768,7 @@ impl<C: Ctx> GroupFn for TableLookUp1D<C> {}
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound = "C::Table: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct CompactCcsTable<C: Ctx> {
-  // // TODO: unit
+  //
   // unit: (),
   #[size = 8]
   #[liberty(name)]
diff --git a/src/internal_power/mod.rs b/src/internal_power/mod.rs
index 85784c8..a15cb72 100644
--- a/src/internal_power/mod.rs
+++ b/src/internal_power/mod.rs
@@ -1,7 +1,7 @@
 use crate::{
   ast::{Attributes, GroupComments, GroupFn},
   common::{
-    items::{Domain, WordSet},
+    items::{Domain, NameList},
     table::TableLookUp,
   },
   expression::LogicBooleanExpression,
@@ -30,14 +30,22 @@ pub struct InternalPower<C: Ctx> {
   // equal_or_opposite_output
   // falling_together_group
   // power_level
-  #[id]
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 64]
   #[liberty(simple)]
-  pub related_pin: WordSet,
-  #[id]
+  pub related_pin: NameList,
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 64]
   #[liberty(simple)]
-  pub related_pg_pin: WordSet,
+  pub related_pg_pin: NameList,
   // rising_together_group
   // switching_interval
   // switching_together_group
diff --git a/src/pin/bundle.rs b/src/pin/bundle.rs
index 5b03f15..c968272 100644
--- a/src/pin/bundle.rs
+++ b/src/pin/bundle.rs
@@ -16,7 +16,11 @@ use crate::{
 #[serde(bound = "C::Pin: serde::Serialize + serde::de::DeserializeOwned")]
 pub struct Bundle<C: Ctx> {
   /// Name of the pin
-  #[id]
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 48]
   #[liberty(name)]
   pub name: NameList,
diff --git a/src/pin/mod.rs b/src/pin/mod.rs
index 98a0c31..6588e41 100644
--- a/src/pin/mod.rs
+++ b/src/pin/mod.rs
@@ -5,7 +5,7 @@ use crate::{
   ast::{Attributes, GroupComments, GroupFn, GroupSet},
   ccsn::{CCSNStage, ReceiverCapacitance},
   common::items::{NameList, WordSet},
-  expression::{logic, BooleanExpression},
+  expression::{logic, BooleanExpression, PowerGroundBooleanExpression},
   internal_power::InternalPower,
   timing::Timing,
   ArcStr, Ctx,
@@ -141,10 +141,9 @@ pub struct Pin<C: Ctx> {
   #[size = 1]
   #[liberty(simple(type = Option))]
   pub alive_during_partial_power_down: Option<bool>,
-  // TODO
   #[size = 32]
   #[liberty(simple(type = Option))]
-  pub power_down_function: Option<BooleanExpression>,
+  pub power_down_function: Option<PowerGroundBooleanExpression>,
   /// <a name ="reference_link" href="
   /// https://zao111222333.github.io/liberty-db/2020.09/reference_manual.html
   /// ?field=test
diff --git a/src/timing/items.rs b/src/timing/items.rs
index ccf45c8..0637afa 100644
--- a/src/timing/items.rs
+++ b/src/timing/items.rs
@@ -8,13 +8,15 @@ use crate::{
     self, fmt_comment_liberty, BuilderScope, GroupComments, GroupFn, ParseScope,
     ParsingBuilder, SimpleAttri,
   },
-  common::table::{DisplayTableLookUp, DisplayValues, TableLookUp},
+  common::{
+    f64_into_hash_ord_fn,
+    table::{DisplayTableLookUp, DisplayValues, TableLookUp},
+  },
   expression::logic,
   ArcStr, Ctx,
 };
 
 use itertools::izip;
-use ordered_float::NotNan;
 use strum_macros::{Display, EnumString};
 /// The `timing_sense` attribute describes the way an input pin logically affects an output pin.
 ///
@@ -275,37 +277,33 @@ impl<C: Ctx> TimingTableLookUp<C> {
   }
   #[must_use]
   #[inline]
+  #[expect(clippy::float_arithmetic)]
   pub fn lookup(&self, idx1: &f64, idx2: &f64) -> Option<f64> {
-    let idx1_ = unsafe { NotNan::new_unchecked(*idx1) };
-    let idx2_ = unsafe { NotNan::new_unchecked(*idx2) };
-    match self
-      .index_1
-      .binary_search_by(|v| unsafe { NotNan::new_unchecked(*v) }.cmp(&idx1_))
-    {
-      Ok(i1_) => match self
-        .index_2
-        .binary_search_by(|v| unsafe { NotNan::new_unchecked(*v) }.cmp(&idx2_))
-      {
-        Ok(i_1) => Some(self.get_value(i1_, i_1)),
-        Err(pos2) => Self::find_pos(self.index_2.len(), pos2).map(|(i_1, i_2)| {
-          let q_1 = self.get_value(i1_, i_1);
-          let q_2 = self.get_value(i1_, i_2);
-          let x_1 = self.index_2[i_1];
-          let x_2 = self.index_2[i_2];
-          q_1 + (q_2 - q_1) * ((idx2 - x_1) / (x_2 - x_1))
-        }),
-      },
+    let idx1_ = f64_into_hash_ord_fn(idx1);
+    let idx2_ = f64_into_hash_ord_fn(idx2);
+    match self.index_1.binary_search_by(|v| f64_into_hash_ord_fn(v).cmp(&idx1_)) {
+      Ok(i1_) => {
+        match self.index_2.binary_search_by(|v| f64_into_hash_ord_fn(v).cmp(&idx2_)) {
+          Ok(i_1) => Some(self.get_value(i1_, i_1)),
+          Err(pos2) => Self::find_pos(self.index_2.len(), pos2).map(|(i_1, i_2)| {
+            let q_1 = self.get_value(i1_, i_1);
+            let q_2 = self.get_value(i1_, i_2);
+            let x_1 = self.index_2[i_1];
+            let x_2 = self.index_2[i_2];
+            // q_1 + (q_2 - q_1) * ((idx2 - x_1) / (x_2 - x_1))
+            (q_2 - q_1).mul_add((idx2 - x_1) / (x_2 - x_1), q_1)
+          }),
+        }
+      }
       Err(pos1) => Self::find_pos(self.index_1.len(), pos1).and_then(|(i1_, i2_)| {
         let x1_ = self.index_1[i1_];
         let x2_ = self.index_1[i2_];
-        match self
-          .index_2
-          .binary_search_by(|v| unsafe { NotNan::new_unchecked(*v) }.cmp(&idx2_))
-        {
+        match self.index_2.binary_search_by(|v| f64_into_hash_ord_fn(v).cmp(&idx2_)) {
           Ok(i_1) => {
             let q1_ = self.get_value(i1_, i_1);
             let q2_ = self.get_value(i2_, i_1);
-            Some(q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_)))
+            // Some(q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_)))
+            Some((q2_ - q1_).mul_add((idx1 - x1_) / (x2_ - x1_), q1_))
           }
           Err(pos2) => Self::find_pos(self.index_2.len(), pos2).map(|(i_1, i_2)| {
             let q11 = self.get_value(i1_, i_1);
@@ -314,9 +312,12 @@ impl<C: Ctx> TimingTableLookUp<C> {
             let q22 = self.get_value(i2_, i_2);
             let x_1 = self.index_2[i_1];
             let x_2 = self.index_2[i_2];
-            let q1_ = q11 + (q12 - q11) * ((idx2 - x_1) / (x_2 - x_1));
-            let q2_ = q21 + (q22 - q21) * ((idx2 - x_1) / (x_2 - x_1));
-            q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_))
+            // let q1_ = q11 + (q12 - q11) * ((idx2 - x_1) / (x_2 - x_1));
+            let q1_ = (q12 - q11).mul_add((idx2 - x_1) / (x_2 - x_1), q11);
+            // let q2_ = q21 + (q22 - q21) * ((idx2 - x_1) / (x_2 - x_1));
+            let q2_ = (q22 - q21).mul_add((idx2 - x_1) / (x_2 - x_1), q21);
+            // q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_))
+            (q2_ - q1_).mul_add((idx1 - x1_) / (x2_ - x1_), q1_)
           }),
         }
       }),
@@ -324,37 +325,33 @@ impl<C: Ctx> TimingTableLookUp<C> {
   }
   #[must_use]
   #[inline]
+  #[expect(clippy::float_arithmetic)]
   pub fn lookup_lvf(&self, idx1: &f64, idx2: &f64) -> Option<LVFValue> {
-    let idx1_ = unsafe { NotNan::new_unchecked(*idx1) };
-    let idx2_ = unsafe { NotNan::new_unchecked(*idx2) };
-    match self
-      .index_1
-      .binary_search_by(|v| unsafe { NotNan::new_unchecked(*v) }.cmp(&idx1_))
-    {
-      Ok(i1_) => match self
-        .index_2
-        .binary_search_by(|v| unsafe { NotNan::new_unchecked(*v) }.cmp(&idx2_))
-      {
-        Ok(i_1) => Some(self.get_lvf_value(i1_, i_1)),
-        Err(pos2) => Self::find_pos(self.index_2.len(), pos2).map(|(i_1, i_2)| {
-          let q_1 = self.get_lvf_value(i1_, i_1);
-          let q_2 = self.get_lvf_value(i1_, i_2);
-          let x_1 = self.index_2[i_1];
-          let x_2 = self.index_2[i_2];
-          q_1 + (q_2 - q_1) * ((idx2 - x_1) / (x_2 - x_1))
-        }),
-      },
+    let idx1_ = f64_into_hash_ord_fn(idx1);
+    let idx2_ = f64_into_hash_ord_fn(idx2);
+    match self.index_1.binary_search_by(|v| f64_into_hash_ord_fn(v).cmp(&idx1_)) {
+      Ok(i1_) => {
+        match self.index_2.binary_search_by(|v| f64_into_hash_ord_fn(v).cmp(&idx2_)) {
+          Ok(i_1) => Some(self.get_lvf_value(i1_, i_1)),
+          Err(pos2) => Self::find_pos(self.index_2.len(), pos2).map(|(i_1, i_2)| {
+            let q_1 = self.get_lvf_value(i1_, i_1);
+            let q_2 = self.get_lvf_value(i1_, i_2);
+            let x_1 = self.index_2[i_1];
+            let x_2 = self.index_2[i_2];
+            // q_1 + (q_2 - q_1) * ((idx2 - x_1) / (x_2 - x_1))
+            (q_2 - q_1).mul_add((idx2 - x_1) / (x_2 - x_1), q_1)
+          }),
+        }
+      }
       Err(pos1) => Self::find_pos(self.index_1.len(), pos1).and_then(|(i1_, i2_)| {
         let x1_ = self.index_1[i1_];
         let x2_ = self.index_1[i2_];
-        match self
-          .index_2
-          .binary_search_by(|v| unsafe { NotNan::new_unchecked(*v) }.cmp(&idx2_))
-        {
+        match self.index_2.binary_search_by(|v| f64_into_hash_ord_fn(v).cmp(&idx2_)) {
           Ok(i_1) => {
             let q1_ = self.get_lvf_value(i1_, i_1);
             let q2_ = self.get_lvf_value(i2_, i_1);
-            Some(q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_)))
+            // Some(q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_)))
+            Some((q2_ - q1_).mul_add((idx1 - x1_) / (x2_ - x1_), q1_))
           }
           Err(pos2) => Self::find_pos(self.index_2.len(), pos2).map(|(i_1, i_2)| {
             let q11 = self.get_lvf_value(i1_, i_1);
@@ -363,9 +360,12 @@ impl<C: Ctx> TimingTableLookUp<C> {
             let q22 = self.get_lvf_value(i2_, i_2);
             let x_1 = self.index_2[i_1];
             let x_2 = self.index_2[i_2];
-            let q1_ = q11 + (q12 - q11) * ((idx2 - x_1) / (x_2 - x_1));
-            let q2_ = q21 + (q22 - q21) * ((idx2 - x_1) / (x_2 - x_1));
-            q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_))
+            // let q1_ = q11 + (q12 - q11) * ((idx2 - x_1) / (x_2 - x_1));
+            let q1_ = (q12 - q11).mul_add((idx2 - x_1) / (x_2 - x_1), q11);
+            // let q2_ = q21 + (q22 - q21) * ((idx2 - x_1) / (x_2 - x_1));
+            let q2_ = (q22 - q21).mul_add((idx2 - x_1) / (x_2 - x_1), q21);
+            // q1_ + (q2_ - q1_) * ((idx1 - x1_) / (x2_ - x1_))
+            (q2_ - q1_).mul_add((idx1 - x1_) / (x2_ - x1_), q1_)
           }),
         }
       }),
@@ -381,16 +381,27 @@ pub struct LVFValue {
   pub std_dev: f64,
   pub skewness: f64,
 }
+impl LVFValue {
+  #[inline]
+  #[must_use]
+  /// self * a + b
+  pub fn mul_add(self, a: f64, b: Self) -> Self {
+    Self {
+      mean: self.mean.mul_add(a, b.mean),
+      std_dev: self.std_dev.mul_add(a, b.std_dev),
+      skewness: self.skewness.mul_add(a, b.skewness),
+    }
+  }
+}
 impl PartialEq for LVFValue {
+  #[inline]
   fn eq(&self, other: &Self) -> bool {
-    unsafe {
-      NotNan::new_unchecked(self.mean) == NotNan::new_unchecked(other.mean)
-        && NotNan::new_unchecked(self.std_dev) == NotNan::new_unchecked(other.std_dev)
-        && NotNan::new_unchecked(self.skewness) == NotNan::new_unchecked(other.skewness)
-    }
+    f64_into_hash_ord_fn(&self.mean) == f64_into_hash_ord_fn(&other.mean)
+      && f64_into_hash_ord_fn(&self.std_dev) == f64_into_hash_ord_fn(&other.std_dev)
+      && f64_into_hash_ord_fn(&self.skewness) == f64_into_hash_ord_fn(&other.skewness)
   }
 }
-#[expect(clippy::arithmetic_side_effects)]
+#[expect(clippy::float_arithmetic)]
 impl Add for LVFValue {
   type Output = Self;
   #[inline]
@@ -402,7 +413,7 @@ impl Add for LVFValue {
     }
   }
 }
-#[expect(clippy::arithmetic_side_effects)]
+#[expect(clippy::float_arithmetic)]
 impl Sub for LVFValue {
   type Output = Self;
   #[inline]
@@ -416,7 +427,7 @@ impl Sub for LVFValue {
     }
   }
 }
-#[expect(clippy::arithmetic_side_effects)]
+#[expect(clippy::float_arithmetic)]
 impl Mul<f64> for LVFValue {
   type Output = Self;
   #[inline]
@@ -442,7 +453,7 @@ impl<C: Ctx> ParsingBuilder for Option<TimingTableLookUp<C>> {
     Option<<TableLookUp<C> as ParsingBuilder>::Builder>,
   );
   #[inline]
-  #[expect(clippy::arithmetic_side_effects)]
+  #[expect(clippy::float_arithmetic)]
   fn build(builder: Self::Builder, _scope: &mut BuilderScope) -> Self {
     #[inline]
     fn eq_index<C: Ctx>(
@@ -504,7 +515,7 @@ impl<C: Ctx> ParsingBuilder for Option<TimingTableLookUp<C>> {
 }
 impl<C: Ctx> TimingTableLookUp<C> {
   #[inline]
-  #[expect(clippy::arithmetic_side_effects)]
+  #[expect(clippy::float_arithmetic)]
   pub(crate) fn fmt_liberty<T: core::fmt::Write, I: ast::Indentation>(
     &self,
     key: &str,
diff --git a/src/timing/mod.rs b/src/timing/mod.rs
index 6267ef7..15bdbcd 100644
--- a/src/timing/mod.rs
+++ b/src/timing/mod.rs
@@ -13,7 +13,7 @@ use crate::{
   ast::{Attributes, GroupComments, GroupFn, GroupSet},
   ccsn::PropagatingCcb,
   common::{
-    items::{SdfEdgeType, WordSet},
+    items::{NameList, SdfEdgeType, WordSet},
     table::{
       CompactCcsTable, ReferenceTimeVector3DGrpup, TableLookUp, TableLookUpMultiSegment,
     },
@@ -567,10 +567,14 @@ pub struct Timing<C: Ctx> {
   /// &end
   /// =203.42
   /// ">Reference-Instance</a>
-  #[id]
+  #[id(
+    borrow = "crate::common::items::RefNameList<'_>",
+    check_fn = "crate::common::items::namelist_borrow",
+    with_ref = false
+  )]
   #[size = 64]
   #[liberty(simple)]
-  pub related_pin: WordSet,
+  pub related_pin: NameList,
   /// The `rise_resistance` attribute represents the load-dependent output resistance,
   /// or drive capability, for a logic 0-to-1 transition.
   ///
diff --git a/src/units.rs b/src/units.rs
index 18c0b8a..0ad0330 100644
--- a/src/units.rs
+++ b/src/units.rs
@@ -247,7 +247,7 @@ pub struct CapacitiveLoadUnit {
 impl CapacitiveLoadUnit {
   #[inline]
   #[must_use]
-  #[expect(clippy::arithmetic_side_effects, clippy::float_arithmetic)]
+  #[expect(clippy::float_arithmetic)]
   pub fn value(&self) -> f64 {
     if self.ff_pf {
       self.val * 1e-15