fn visit_map<__A>(self, mut __map: __A) -> Result<Self::Value, __A::Error>
where __A: serde::de::MapAccess<'de>
{
    let mut __field1: Option<u64> = None; // blobGasUsed
    let mut __field2: Option<u64> = None; // excessBlobGas

    // This is the expensive part: ALL unrecognized keys + values
    // get buffered into a Vec of Content pairs
    let mut __collect = Vec::<
        Option<(
            serde::__private::de::Content,  // key
            serde::__private::de::Content,  // value (!)
        )>,
    >::new();

    while let Some(__key) = __map.next_key::<__Field>()? {
        match __key {
            __Field::__field1 => { /* deserialize blobGasUsed */ }
            __Field::__field2 => { /* deserialize excessBlobGas */ }

            // Every other field (all 14 V1 fields + withdrawals)
            // gets captured as Content — meaning the full JSON value
            // is parsed into an owned enum tree:
            __Field::__other(__name) => {
                __collect.push(Some((
                    __name,
                    __map.next_value_seed(ContentVisitor::new())?,
                    //                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    // This allocates: every Bytes tx blob, the Bloom,
                    // all B256 hashes — all become Content::String(String)
                )));
            }
        }
    }

    // Then the collected Content pairs are re-deserialized through
    // FlatMapDeserializer, which reconstructs ExecutionPayloadV2
    // from the buffered data — causing a SECOND deserialization pass
    let __field0: ExecutionPayloadV2 = Deserialize::deserialize(
        FlatMapDeserializer(&mut __collect, PhantomData),
        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        // This re-parses every Content value back into its real type,
        // doubling allocations for String -> B256, String -> Bloom, etc.
    )?;

    // And ExecutionPayloadV2 does the SAME thing internally for V1,
    // creating a 3rd Content buffer + FlatMapDeserializer pass
}

impl<'de> Deserialize<'de> for ExecutionPayloadV3 {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(rename_all = "camelCase")]
        struct Helper {
            parent_hash: B256,
            fee_recipient: Address,
            // ... all fields flat, no nesting ...
            transactions: Vec<Bytes>,
            withdrawals: Vec<Withdrawal>,
            #[serde(with = "alloy_serde::quantity")]
            blob_gas_used: u64,
            #[serde(with = "alloy_serde::quantity")]
            excess_blob_gas: u64,
        }

        let helper = Helper::deserialize(deserializer)?;
        Ok(Self {
            payload_inner: ExecutionPayloadV2 {
                payload_inner: ExecutionPayloadV1 { /* fields from helper */ },
                withdrawals: helper.withdrawals,
            },
            blob_gas_used: helper.blob_gas_used,
            excess_blob_gas: helper.excess_blob_gas,
        })
    }
}