The optimized code achieves an 18% speedup by eliminating expensive dictionary operations in the datetime parsing path. The key optimization is replacing the original approach of creating a dictionary via `match.groupdict()` and then iterating over it with `{k: int(v) for k, v in kw.items() if v is not None}`, with direct field extraction and conversion.

**Specific optimizations:**

1. **Direct field extraction**: Instead of `kw = match.groupdict()` followed by dictionary comprehension, the code directly accesses `gd['year']`, `gd['month']`, etc., eliminating the intermediate dictionary creation and iteration overhead.

2. **Conditional microsecond processing**: The microsecond padding logic (`ljust(6, "0")`) now only executes when microseconds are actually present, avoiding unnecessary string operations in cases without microseconds.

3. **Inline integer conversions**: Fields are converted to integers immediately upon extraction (`int(gd['year'])`) rather than through a dictionary comprehension, reducing function call overhead.

4. **Eliminated type annotation overhead**: Removed the `Dict[str, Union[None, int, timezone]]` type annotation for the intermediate dictionary since it's no longer needed.

**Why this is faster:**
Dictionary operations in Python have significant overhead - creating dictionaries, iterating with `.items()`, and key lookups are all expensive. The optimization eliminates these entirely for the common datetime parsing case. The test results show consistent 15-25% improvements for ISO string parsing cases, which represent the most common use pattern where these dictionary operations were the bottleneck.

The optimizations are most effective for ISO string inputs (the majority of test cases showing 15-27% improvements), while having minimal impact on numeric timestamp inputs that bypass this parsing logic entirely.