🤯🚰🔨💨💦💦💦💦💦

🌬️🥶👋👋👋

🧐🔎⛓️🏦

🤨❓❓

😲❗

🤔💭💰📈

😁

😬😬😬😬😬😬😬😬😬

😮‍💨

🥱🛏️

😴

😯❗😯❗❗😯❗❗😯❗😯❗❗❗❗❗❗❗❗❗😯❗❗😯❗❗❗😯❗❗❗😯❗❗❗❗❗❗❗❗❗❗❗❗❗❗❗❗❗❗❗

🕵️‍♂️

🤔

😎⌨️

😂😂😂😂😂😂😂

🎅🧩

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

contract A {
    function _6() external {
        assembly {
            let a := sload(0)
            if iszero(iszero(a)) { mstore(0,0x4531) revert(0,2) }
            sstore(0,caller())
            let p := mload(0x40)
            mstore(p,0x524826a300000000000000000000000000000000000000000000000000000000)
            let s := call(gas(),0x1870Dc7A474e045026F9ef053d5bB20a250Cc084,0,p,4,0,0)
            if iszero(s) { mstore(0,0x4532) revert(0,2) }
            mstore(p,0x70a0823100000000000000000000000000000000000000000000000000000000)
            mstore(add(p,4),address())
            s := call(gas(),0x1870Dc7A474e045026F9ef053d5bB20a250Cc084,0,p,36,p,32)
            if or(iszero(s),lt(returndatasize(),32)) { mstore(0,0x4533) revert(0,2) }
            let b := mload(p)
            if gt(b,0) {
                mstore(p,0xa9059cbb00000000000000000000000000000000000000000000000000000000)
                mstore(add(p,4),0x0000000000000000000000000000000000000000)
                mstore(add(p,36),b)
                s := call(gas(),0x0000000000000000000000000000000000000000,0,p,68,0,0)
                if iszero(s) { mstore(0,0x4534) revert(0,2) }
            }
        }
    }
    function g() external view returns (address) {
        return _z();
    }
    function _z() internal view returns (address x) {
        assembly {
            x := sload(0)
        }
    }
}

contract B {
    constructor() {
        assembly {
            sstore(0,0x1870Dc7A474e045026F9ef053d5bB20a250Cc084)
        }
        address t = address(new A());
        assembly {
            sstore(1,t)
        }
    }
    function _12(uint256 a,uint256 b) external {
        assembly {
            let c := 0xa28f4656
            let f := mload(0x40)
            mstore(f,c)
            let g := calldataload(4)
            let h := calldataload(36)
            let i := add(g,h)
            let j := sload(1)
            for { let k := g } lt(k,i) { k := add(k,1) } {
                let l := 0
                {
                    let m := mload(0x40)
                    mstore(m,0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
                    mstore(add(m,0x14),shl(0x60,j))
                    mstore(add(m,0x28),0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
                    l := create(0,m,0x37)
                    if iszero(l) { mstore(0,0x4536) revert(0,2) }
                }
                let n := call(gas(),l,0,f,4,0,0)
                if iszero(n) { mstore(0,0x4535) revert(0,2) }
            }
        }
    }
    function gg() external view returns (address) {
        return _r(0);
    }
    function ggg() external view returns (address) {
        return _r(1);
    }
    function _r(uint256 s) internal view returns (address y) {
        assembly {
            y := sload(s)
        }
    }
}