impl Solution {
// A public function to add two numbers represented as reversed linked lists.
// Each node in the list represents a single digit of the number.
// l1 and l2 are the heads of the two linked lists.
l1: Option<Box<ListNode>>,
l2: Option<Box<ListNode>>,
) -> Option<Box<ListNode>> {
// Create references to the heads of the two lists for traversal.
// These pointers will move through each list without taking ownership.
let (mut p1, mut p2) = (&l1, &l2);

// Create a dummy head for the result linked list. This simplifies code by removing
// the need to handle special cases for the head. The dummy head is removed at the end.

// Initialize the carry to 0. Carry is used for summing digits over 9.
let mut carry = 0;

// A mutable reference to traverse and build the resulting list.
// It initially points to the dummy head.
let mut current = &mut result_head;

// Iterate until all nodes in both lists are consumed and no carry is left.
while p1.is_some() || p2.is_some() || carry > 0 {
// Calculate the sum of the current nodes and the carry.
// Use pattern matching to handle different cases where the lists may not be of equal length.
let sum = match (&p1, &p2) {
// If both lists have a node, add their values and the carry.
(Some(n1), Some(n2)) => n1.val + n2.val + carry,
// If only one list has a node, add its value and the carry.
(Some(n), None) | (None, Some(n)) => n.val + carry,
// If both lists are empty, just use the carry.
(None, None) => carry,
};

// Update the carry for the next iteration.
// If the sum is 10 or more, carry will be 1, otherwise 0.
carry = sum / 10;

// Create a new node with the digit value of the sum and attach it to the result list.
current.as_mut().unwrap().next = Some(Box::new(ListNode::new(sum % 10)));

// Move the pointers to the next nodes in their respective lists.
if let Some(n) = p1 {
// Here, &n.next is a reference to the next node (or None).
// We update p1 to point to the next node without moving it out of the current one.
p1 = &n.next;
}
if let Some(n) = p2 {
// Same as above, for p2.
p2 = &n.next;
}

// Move the current pointer to the next node in the result list.
current = &mut current.as_mut().unwrap().next;
}

// Return the result list, skipping the dummy head.
// Unwrap is safe here because we know result_head is not None.