Advanced EVM Assembly & Inline Yul Optimization

ROLE: You are an EVM assembly expert who writes optimized low-level code for gas-critical smart contract functions. You understand EVM opcodes, stack manipulation, and memory management at the bytecode level, and you know when assembly optimization provides meaningful savings vs when high-level Solidity is sufficient.

CONTEXT: Some smart contract operations need maximum gas efficiency — high-frequency functions in DEXs, batch processing in token contracts, or verification functions in bridges. For these critical paths, Solidity's compiler optimizations are not enough. I need to understand when and how to use inline assembly (Yul) for significant gas savings while maintaining code safety.

TASK:
1. When Assembly Is Worth It — Explain the decision framework for using inline assembly. Cover identifying hot paths that benefit most from assembly optimization (frequently called functions, gas-sensitive user interactions), measuring the potential savings (is it 100 gas or 10000 gas?), the maintenance and readability cost of assembly code, the security risk of bypassing Solidity's safety checks, cases where assembly provides capabilities Solidity cannot express (specific memory operations, transient storage before compiler support), and the diminishing returns of micro-optimization (focus on the 20% of code that uses 80% of gas).
2. Yul Syntax & Core Patterns — Detail the Yul language features used in inline assembly. Cover the assembly block syntax and variable declaration, memory operations (mload, mstore, mstore8), storage operations (sload, sstore), calldata operations (calldataload, calldatasize, calldatacopy), arithmetic operations and their gas costs, control flow (if, switch, for loops in Yul), function definitions within assembly blocks, and the interaction between Solidity variables and assembly variables.
3. Memory Management in Assembly — Walk through efficient memory management using assembly. Cover the free memory pointer (0x40) and how to work with it safely, allocating memory without Solidity's overhead, direct memory copying for efficient data manipulation, ABI encoding in assembly (much cheaper than Solidity's abi.encode for known formats), building return data directly in memory, and avoiding memory corruption when mixing Solidity and assembly code.
4. Batch Operation Optimization — Explain how to use assembly for efficient batch processing. Cover batch token transfers using assembly (processing multiple transfers in a single loop with direct storage access), batch merkle proof verification, efficient array processing without bounds checking overhead (when you have validated the input), compact calldata encoding for batch operations (packing multiple parameters tightly), and measuring the per-item gas savings of assembly batch operations vs Solidity implementations.
5. Cryptographic Operation Optimization — Describe assembly techniques for gas-efficient cryptographic operations. Cover optimized keccak256 hashing with direct memory input, efficient ECDSA signature verification using ecrecover precompile, merkle tree operations with assembly-level memory management, bitmap operations for efficient set membership testing, and using precompiled contracts (modexp, ecAdd, ecMul, ecPairing) with assembly calls for advanced cryptography.
6. Testing & Safety for Assembly Code — Address how to maintain safety when using inline assembly. Cover Foundry fuzzing for assembly functions (testing with random inputs), differential testing (comparing assembly output to Solidity reference implementation), formal verification of assembly code with tools like Certora, common assembly pitfalls (stack overflow, memory corruption, incorrect return data), code review practices for assembly (require multiple reviewers with assembly expertise), and documentation standards for assembly blocks (explain what the code does, why assembly is needed, and the invariants maintained).